Pourquoi est une itération à travers un tableau plus rapide vers l'arrière que vers l'avant

Étant donné ce code:

var arr = [];

for (var i = 0; i < 10000; ++i)
    arr.push(1);

Transmet

for (var i = 0; i < arr.length; ++i) {}

En arrière

for (var i = arr.length - 1; i >= 0; --i) {}

Codée en dur de l'Avant

for (var i = 0; i < 10000; ++i) {}

Pourquoi est vers l'arrière de manière beaucoup plus rapide?

Voici le test:
http://jsperf.com/array-iteration-direction

InformationsquelleAutor samccone | 2011-12-31
  1. 81

    Parce que votre avant-condition pour recevoir la length propriété de votre tableau à chaque fois, tandis que l'autre n'a qu'à cocher pour "supérieure à zéro", un très rapide de tâche.

    Lorsque votre longueur du tableau ne change pas au cours de la boucle, et vous regardez vraiment ns performance, vous pouvez utiliser

    for (var i=0, l=arr.length; i<l; i++)

    BTW: au Lieu de for (var i = arr.length; i > 0; --i) vous pouvez utiliser for (var i = arr.length; i-- > 0; ) qui fonctionne vraiment par l'intermédiaire de votre tableau de n-1 à 0, pas de n à 1.

    • Yep, c'est comment je fais pour l'optimisation de fonctions. Il suffit de noter que si le tableau est mutable (et il n'est généralement pas), cela peut ignorer une ressource ou deux. Par exemple, cela ne fonctionnera pas si vous êtes une boucle sur les éléments de la boucle elle-même est de l'ajout ou de la suppression.
    • vous pouvez même le faire for(... ; i-- ;)
    • donc, fondamentalement, cela signifie que si je ne change pas le tableau et je garde le tableau.longueur dans une variable, puis vers l'arrière de la vitesse = vitesse vers l'avant? Exemple: var longueur = array.length; for(var i = 0 ; i<longueur ; i++);
    • autant que je sache, i<l est un autre calcul que i>0, mais oui, ils sont plutôt égale (plus rapide que le cache de la longueur): jsperf.com/array-iteration-direction/3 - pourtant, certains moteurs de reconnaître et d'optimiser certains de ces cas
    • La condition d'une boucle est évalué à chaque itération. Pensez-y comme var i = 0; var a = i < 10; while(a) { i++; a = i < 10; }.
    • Et alors? Bien sûr, il doit l'être. Ai-je dit quelque chose d'autre?
    • Isnt cette boucle for (var i = arr.length; i-- > 0; ) va manquer l'indice 0 1-- !>0? peut-être que ce doit être for (var i = arr.length; i-- >= 0; )
    • Pas de. Le i dans le corps de la boucle (après avoir été décrémenté) est toujours plus petit que le i vu dans la condition (avant d'être décrémentée). Ce que vous avez besoin est for (var i=arr.length-1; i>=0; --i)
    • testé, oui 0 est ici, honnêtement, je ne comprends pas encore pourquoi, n'est-il pas en premier lieu décrémente i, puis la compare à 0, puis décide de faire de l'itération ou pas. Comme cela, il semble que 1 doit être décrémenté à 0, donc pas de départ de l'itération comme il n'est pas > 0
    • Lire sur préfixe/suffixe de décrémentation les opérateurs alors
    • Oh snap!! vous avez ouvert mes yeux, quelle honte, je vous remercie)
    • Avance rapide jusqu'en 2018. elle ressemble moderne versions des navigateurs ne pas faire de boucle ralentissement de même, lors de l'accès arr.la longueur de chaque itération (vos attaquants de cas)

    InformationsquelleAutor Bergi
  2. 8

    Parce que dans le premier formulaire, vous êtes accédant à la propriété length de la matrice arr une fois pour chaque itération, alors que dans le second vous ne le faites qu'une fois.

    • quels résultats avez-vous déjà vu (qui test dans le navigateur)? Je vois que la mise en cache de la longueur est toujours au moins aussi rapide et généralement plus rapide.
    • bien, vous avez raison... on dirait qu'il est vraiment un sac mélangé des résultats tho, mais la mise en cache de l'aider... merci XD
    InformationsquelleAutor rabusmar
  3. 6

    Si vous voulez les avoir au même rythme, vous pouvez le faire pour l'avenir de l'itération;

    for(var i=0, c=arr.length; i<c; i++){
}

    Donc, votre script n'aurez pas besoin de prendre la longueur de la matrice sur everystep.

    InformationsquelleAutor tcak
  4. 4

    Je ne suis pas entièrement sûr de cela, mais voici ma conjecture:

    Pour le code suivant:

    for (var i = 0; i < arr.length; ++i) {;
}

    Au cours de l'exécution, il y a un arr.calcul de la longueur après chaque tour de boucle. Cela peut être une opération triviale quand il est seul, mais peut avoir un impact quand il s'agit de plusieurs tableaux de grande. Pouvez-vous essayer le suivant:

     var numItems = arr.length;
    for(var i=0; i< numItems; ++i)
    {
    }

    Dans le code ci-dessus, on calcule la longueur du tableau, juste une fois, et de fonctionner avec que le calcul de nombre, plutôt que d'effectuer la longueur de calcul de plus et plus de nouveau.

    De nouveau, juste de mettre mes pensées ici. Observation intéressante en effet!

    InformationsquelleAutor Gopal Nair
  5. 2

    i > 0 est plus rapide que i < arr.length et se produit à chaque itération de la boucle.

    Vous pouvez atténuer la différence:

    for (var i = 0, len = arr.length; i < len; ++i) {;
}

    Ce n'est pas encore aussi rapide que le vers l'arrière de l'élément, mais plus rapide que votre option.

    InformationsquelleAutor jfriend00
  6. 1

    faire comme ci-dessous, il fonctionnera de la même façon. parce que arr.length prend du temps à chaque itération de l'avant.

    int len = arr.length;

    avant

    for (var i = 0; i < len; ++i) {
}

    arrière

    for (var i = len; i > 0; --i) {
}
    • L'arrière de cas n'est pas droit. Ce que je fais est for(i=len; --i>=0;){
    • for (let i = arr.length; i-- > 0;) {
    InformationsquelleAutor dku.rajkumar
  7. 1

    Et elles sont aussi bonnes:

    var arr= [], L= 10000;
while(L>-1) arr[L]= L--;

    OU

    var arr= [], i= 0;
while(i<10001) arr[i]=i++;
    • hahaha délicat délicat
    • Il devrait être while(--L>=0) arr[L] = L;
    InformationsquelleAutor kennebec