Taille maximale d'un tableau en Javascript

Question

Contexte : Je suis en train de construire un petit site qui lit un flux rss, et met à jour/contrôle le flux en arrière-plan. J'ai un tableau pour stocker les données à afficher, et un autre qui stocke les ID des enregistrements qui ont été affichés.

Question : Combien d'éléments un tableau peut-il contenir en Javascript avant que les choses ne commencent à devenir lentes, ou paresseuses. Je ne trie pas le tableau, mais j'utilise la fonction inArray de jQuery pour effectuer une comparaison.

Le site web restera actif et mis à jour et il est peu probable que le navigateur soit redémarré ou actualisé aussi souvent.

Si j'envisage de supprimer certains enregistrements du tableau, quelle est la meilleure façon de supprimer certains enregistrements après une limite, par exemple 100 éléments.

Answer 1

La durée maximale jusqu'à ce que "ça devienne lent" dépend totalement de votre machine cible et de votre code réel, vous devrez donc faire des tests sur cette (ces) plateforme(s) pour voir ce qui est acceptable.

Toutefois, la longueur maximale d'un tableau selon la spécification de la 5e édition de l'ECMA-262 est limitée à un entier non signé de 32 bits en raison de la règle suivante ToUint32 opération abstraite, de sorte que le tableau le plus long possible pourrait avoir 2 32 -1 = 4 294 967 295 = 4,29 milliards d'éléments.

Answer 2

Il n'est pas nécessaire de découper le tableau, il suffit de l'adresser comme un tampon circulaire (index % maxlen). Cela garantit qu'il ne dépassera jamais la limite (la mise en œuvre d'un tampon circulaire signifie qu'une fois que vous arrivez à la fin, vous revenez au début - il n'est pas possible de dépasser la fin du tableau).

Par exemple :

var container = new Array ();
var maxlen = 100;
var index = 0;

// 'store' 1538 items (only the last 'maxlen' items are kept)
for (var i=0; i<1538; i++) {
   container [index++ % maxlen] = "storing" + i;
}

// get element at index 11 (you want the 11th item in the array)
eleventh = container [(index + 11) % maxlen];

// get element at index 11 (you want the 11th item in the array)
thirtyfifth = container [(index + 35) % maxlen];

// print out all 100 elements that we have left in the array, note
// that it doesn't matter if we address past 100 - circular buffer
// so we'll simply get back to the beginning if we do that.
for (i=0; i<200; i++) {
   document.write (container[(index + i) % maxlen] + "<br>\n");
}

Answer 3

Comme @maerics l'a dit, votre machine cible et votre navigateur détermineront les performances.

Mais pour quelques chiffres réels, sur mon Chromebook 2017 d'entreprise, en exécutant l'opération :

console.time();
Array(x).fill(0).filter(x => x < 6).length
console.timeEnd();

• x=5e4 prend 16 ms, ce qui est suffisant pour 60 images par seconde
• x=4e6 prend 250 ms, ce qui est perceptible mais ne constitue pas un problème majeur
• x=3e7 prend 1300ms, ce qui est plutôt mauvais
• x=4e7 prend 11 000 ms et alloue 2,5 Go de mémoire supplémentaire

Une limite supérieure d'environ 30 millions d'éléments est donc difficile à atteindre, car la VM javascript s'effondre à partir de 40 millions d'éléments et fera probablement échouer le processus.

---

EDIT : Dans le code ci-dessus, je remplis le tableau avec des éléments et je les parcours en boucle, simulant ainsi le minimum de ce qu'une application pourrait vouloir faire avec un tableau. Si vous exécutez simplement Array(2**32-1) vous créez un tableau clairsemé qui est plus proche d'un objet JavaScript vide avec une longueur, comme {length: 4294967295} . Si vous essayez réellement d'utiliser ces 4 milliards d'éléments, vous ferez certainement échouer le processus javascript.

Answer 4

Vous pouvez essayer quelque chose comme ceci pour tester et réduire la longueur :

http://jsfiddle.net/orolo/wJDXL/

var longArray = [1, 2, 3, 4, 5, 6, 7, 8];

if (longArray.length >= 6) {
  longArray.length = 3;
}

alert(longArray); //1, 2, 3

Answer 5

J'ai construit un cadre de performance qui manipule et représente graphiquement des millions d'ensembles de données, et même dans ce cas, la latence de calcul du javascript était de l'ordre de quelques dizaines de millisecondes. À moins que vous ne craigniez de dépasser la limite de taille des tableaux, je ne pense pas que vous ayez à vous inquiéter.