Taille maximale d'un tableau en Javascript

Contexte: Je construis un petit site qui lit un flux rss et met à jour / vérifie 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 lentes. Je ne trie pas le tableau, mais j'utilise la fonction inArray de jQuery pour faire une comparaison.

Le site Web sera laissé en cours d'exécution et mis à jour et il est peu probable que le navigateur soit redémarré / actualisé aussi souvent.

Si je devais penser à effacer certains enregistrements du tableau, quel est le meilleur moyen de supprimer certains enregistrements après une limite, comme 100 éléments.

La longueur maximale jusqu'à ce que "ça devienne lent" dépend totalement de votre machine cible et de votre code réel, vous devrez donc tester sur cette (ces) plate-forme (s) pour voir ce qui est acceptable.

Cependant, la longueur maximale d'un tableau selon la spécification ECMA-262 5th Edition est lié par un entier non signé de 32 bits en raison de la ToUint32 opération abstraite, de sorte que la plus longue rangée possible pourrait avoir 2 ³² -1 = 4,294,967,295 = 4,29 milliards éléments .

Pas besoin de découper le tableau, il suffit de l'adresser comme un tampon circulaire (index% maxlen). Cela garantira qu'il ne dépasse jamais la limite (l'implémentation d'un tampon circulaire signifie qu'une fois que vous arrivez à la fin, vous revenez au début - 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");
}

Vous pouvez essayer quelque chose comme ceci pour tester et couper 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

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

Mais pour certains chiffres du monde réel, sur mon Chromebook d'entreprise 2017, exécutant l'opération:

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

• x=5e4 prend 16ms, assez bien pour 60fps
• x=4e6 prend 250ms, ce qui est perceptible mais pas un gros problème
• x=3e7 prend 1300ms, ce qui est assez mauvais
• x=4e7 prend 11000 ms et alloue 2,5 Go supplémentaires de mémoire

Donc, environ 30 millions d'éléments est une limite supérieure stricte, car la machine virtuelle javascript tombe d'une falaise à 40 millions d'éléments et fera probablement planter le processus.

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

Cela dépendra beaucoup du navigateur. 100 éléments ne sonne pas comme un grand nombre - je suppose que vous pourriez aller beaucoup plus haut que cela. Les milliers ne devraient pas être un problème. Ce qui peut poser problème, c'est la consommation totale de mémoire.

J'ai sans vergogne tiré de gros ensembles de données en mémoire, et bien que cela soit devenu lent, il a fallu peut-être 15 Mo de données avec des calculs assez intenses sur l'ensemble de données. Je doute que vous rencontriez des problèmes de mémoire à moins que vous n'ayez des calculs intenses sur les données et de nombreuses lignes. Le profilage et l'analyse comparative avec différents ensembles de résultats simulés seront votre meilleur pari pour évaluer les performances.