Ci sono dei vantaggi nell'usare questa variabile extra nell'annotazione del ciclo for?

Ho trovato la seguente annotazione in loop in un grande progetto a cui sto lavorando (pseudocodice):

var someOtherArray = [];
for (var i = 0, n = array.length; i < n; i++) {
    someOtherArray[i] = modifyObjetFromArray(array[i]);
}

Ciò che ha attirato la mia attenzione è questa variabile "n" aggiuntiva. Non ho mai visto un for lop scritto in questo modo prima d'ora.

Ovviamente in questo scenario non c'è motivo per cui questo codice non possa essere scritto nel modo seguente (al quale sono molto abituato):

var someOtherArray = [];
for (var i = 0; i < array.length; i++) {
    someOtherArray[i] = modifyObjetFromArray(array[i]);
}

Ma mi ha fatto pensare.

C'è uno scenario in cui scrivere un tale ciclo for avrebbe senso? L'idea mi viene in mente che la lunghezza della "matrice" può cambiare durante l'esecuzione del ciclo for, ma non vogliamo fare un loop oltre la dimensione originale, ma non riesco a immaginare un simile scenario.

Anche la riduzione dell'array all'interno del ciclo non ha molto senso, perché è probabile che si ottenga OutOfBoundsException.

Esiste un modello di progettazione noto in cui questa annotazione è utile?

Modifica Come notato da @ Jerry101 il motivo è la prestazione. Ecco un link al test delle prestazioni che ho creato: http://jsperf.com/ninforloop . A mio avviso, la differenza non è abbastanza grande a meno che non si stia ripetendo un array molto grande. Il codice da cui l'ho copiato aveva solo un massimo di 20 elementi, quindi penso che la leggibilità in questo caso superi la considerazione delle prestazioni.

La variabile ngarantisce che il codice generato non recuperi la lunghezza dell'array per ogni iterazione.

È un'ottimizzazione che potrebbe fare la differenza nel tempo di esecuzione a seconda della lingua utilizzata, se l'array è effettivamente un oggetto di raccolta o un "array" JavaScript e altri dettagli di ottimizzazione.

Il recupero della lunghezza dell'array può essere facilmente "più costoso" dell'azione effettiva su cui si ripete.

Quindi se il set non cambia, interroga la lunghezza solo una volta.

Non con gli array, ma con i set di record provenienti da un server sql ho visto notevoli miglioramenti non interrogando il conteggio dei record in ogni iterazione. (ovviamente fallo solo se puoi garantire che l'array o il set di record non vengano modificati durante questo processo).

L'idea mi viene in mente che la lunghezza della "matrice" può cambiare durante l'esecuzione del ciclo for, ma non vogliamo fare un loop oltre la dimensione originale, ma non riesco a immaginare un simile scenario.

Le persone che parlano delle prestazioni probabilmente hanno ragione sul fatto che è per questo che è stato scritto in quel modo (la persona che l'ha scritto in quel modo potrebbe non essere corretta e influire in modo significativo sulle prestazioni, ma è un'altra cosa).

Tuttavia, per rispondere a questa parte della tua domanda, penso che sia più probabile che accada quando lo scopo principale del loop è modificare l'array su cui si sta eseguendo il loop. Prendi in considerazione qualcosa del genere, in pseudo-codice:

guests = [];
for (i = 0; i < invitations.length; ++i) {
    if (! invitations[i].is_declined()) {
        guests.append(invitations[i].recipient())
    }
}
// maybe some other stuff to modify the guestlist
for (i = 0, n = guests.length; i < n; ++i) {
    if (guests[i].has_plus_one()) {
        guests.append(guests[i].get_plus_one());
    }
}

Naturalmente ci sono altri modi per scriverlo. In questo caso, avrei potuto controllare i più contemporaneamente verificando se i destinatari accettavano i loro inviti e producendo l'elenco completo degli ospiti un invito alla volta. Non voglio necessariamente combinare queste due operazioni, ma non riesco immediatamente a pensare a un motivo per cui questo è decisamente sbagliato e quindi è richiesto questo design . È un'opzione da considerare, di tanto in tanto.

In realtà penso che la cosa più sbagliata con questo codice sia che l'appartenenza alla guestsmatrice significhi cose diverse in punti diversi del codice. Quindi certamente non lo definirei un "modello", ma non so che è abbastanza un difetto escludere di fare qualsiasi cosa di questo tipo :-)

Se possibile, è necessario utilizzare un iteratore che attraversa tutti gli elementi dell'array. Si utilizza l'array solo come una sequenza, non come memoria ad accesso casuale, quindi sarebbe ovvio che un iteratore che esegue semplicemente un accesso sequenziale sarebbe più veloce. Immagina che ciò che pensi sia un array in realtà è un albero binario, ma qualcuno ha scritto un codice che determina la "lunghezza" contando gli elementi e il codice che accede all'i-esimo elemento, anche attraversando l'elemento, ognuno in O (n ). Un iteratore può essere molto veloce, il tuo loop sarà sloooooow.