Perché l'iterazione attraverso una serie avanti più velocemente allora in avanti

Question

Dato questo codice

var arr = []; 
    for (var i = 0; i < 10000; ++i) { 
     arr.push(1); 
    } 

Attaccanti

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

indietro

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

hard coded F orward

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

perché il backwords è molto più veloce?

Qui è la prova http://jsperf.com/array-iteration-direction

Answer 1

Poiché l'avanti-condizione deve ricevere la proprietà length dell'array ogni volta, mentre l'altra condizione ha solo per verificare "maggiore di zero", un compito molto veloce.

Quando la lunghezza della matrice non cambia durante il ciclo, e davvero guardare ns-perfomance, è possibile utilizzare

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

BTW: Invece di for (var i = arr.length; i > 0; --i) si potrebbe utilizzare for (var i = arr.length; i-- > 0;) che corre proprio attraverso l'array da n-1 a 0, non da n a 1.

Answer 2

Perché nel primo modulo si accede alla proprietà length dell'array arr una volta per ogni iterazione, mentre nel secondo si fa solo una volta.

Answer 3

i > 0 è più veloce di i < arr.length e si verifica a ogni iterazione del ciclo.

è possibile attenuare la differenza con questo:

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

Questo non è ancora veloce come la voce indietro, ma più velocemente di quanto la vostra opzione in avanti.

Answer 4

Se si desidera avere lo stesso ritmo, è possibile farlo per l'iterazione di inoltro;

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

Così, lo script non avrà bisogno di prendere la lunghezza della matrice su everystep.

Answer 5

E questi sono altrettanto buone:

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

O

var arr= [], i= 0; 
while(i<10001) arr[i]=i++; 

Answer 6

Non sono del tutto sicuro di questo, ma qui è la mia ipotesi:

Per il seguente codice:

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

D Durante il runtime, c'è un calcolo di arr.length dopo ogni loop pass. Questa può essere un'operazione banale quando è isolata, ma può avere un impatto quando si tratta di array multipli/enormi. Si può provare il seguente:

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

Nel codice precedente, si calcola la lunghezza della matrice sola volta, e operare con quel numero calcolato, invece di eseguire il calcolo lunghezza più e più volte.

Ancora una volta, sto solo mettendo i miei pensieri qui. Osservazione interessante davvero!

Answer 7

farlo come di seguito, si esibirà nello stesso modo.perché arr.length richiede tempo in ogni iterazione in avanti.

int len = arr.length; 

avanti

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

all'indietro

for (var i = len; i > 0; --i) { 
}