JavaScript performance de la boucle - Pourquoi est-à décrémenter l'itérateur vers 0 plus vite que l'incrémentation

Je crois que la raison est parce que vous êtes en comparant le point de fin de boucle contre 0, ce qui est plus rapide que la comparaison de nouveau < length (ou d'une autre variable JS).

C'est parce que l'ordinal opérateurs <, <=, >, >= sont polymorphes, de sorte que ces opérateurs exigent des vérifications de type sur les deux côtés gauche et droit de l'opérateur de déterminer quelle comparaison du comportement doit être utilisé.

Il y a quelques très bons repères disponibles ici:

Quel est le Moyen le plus Rapide de coder une Boucle en JavaScript

OriginalL'auteur djdd87

Que sur l'utilisation d'un revers boucle while alors:

var values = [1,2,3,4,5]; 
var i = values.length; 

/* i is 1st evaluated and then decremented, when i is 1 the code inside the loop 
   is then processed for the last time with i = 0. */
while(i--)
{
   //1st time in here i is (length - 1) so it's ok!
   process(values[i]);
}

De l'OMI, ce l'un au moins est un plus readble code de for(i=length; i--;)

OriginalL'auteur Marco Demaio

Y est encore plus "performant" version de ce.
Étant donné que chaque argument est facultatif dans les boucles for, vous pouvez ignorer même le premier.

var array = [...];
var i = array.length;

for(;i--;) {
    do_teh_magic();
}

Avec ce que vous ignorez même le contrôle sur le [initial-expression]. Si vous vous retrouvez avec une seule opération gauche.

OriginalL'auteur icanhazstring

J'ai effectué un test sur C# et C++ (même syntaxe). Il y a, en fait, la performance diffère essentiellement dans for boucles, comparativement à do while ou while. En C++, la performance est plus importante lorsque l'incrémentation. Il peut également dépendre du compilateur.

En Javascript, je pense, tout dépend du navigateur (moteur Javascript), mais ce comportement est attendu. Javascript est optimisé pour travailler avec les DOM. Alors, imaginez-vous en boucle à travers une collection d'éléments DOM, vous obtenez à chaque itération, et vous incrémenter un compteur, quand vous avez à les supprimer. Vous retirez le 0 élément, puis 1 élément, mais ensuite vous sautez celui qui prend 0's place. Si la boucle vers l'arrière que le problème disparaît. Je sais que l'exemple donné n'est pas seulement le droit, mais je n'ai rencontrer des situations où j'ai dû supprimer des éléments à partir d'une modification de l'objet de collection.

Parce que descendante de la boucle est le plus souvent inévitable qu'un transfert en boucle, je devine que le JS moteur est optimisé pour ça.

OriginalL'auteur AlexanderMP

Je ne suis pas sûr si c'est plus rapide mais l'une des raisons que je vois, c'est que lorsque vous parcourez un tableau des éléments d'une taille à l'aide d'incrément vous avez tendance à écrire:

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

Vous êtes essentiellement l'accès à la propriété length de la matrice de N (nombre d'éléments) fois.
Alors que quand vous décrémentation, vous avez accès qu'une seule fois. Que pourrait être une raison.

Mais vous pouvez aussi écrire à l'incrémentation de la boucle comme suit:

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

OriginalL'auteur naikus