Le variabili JavaScript dichiarano il ciclo esterno o interno?

In AS3 credo che dovresti inizializzare tutte le variabili al di fuori dei loop per migliorare le prestazioni. È anche questo il caso di JavaScript? Quale è migliore / più veloce / best-practice?

var value = 0; for (var i = 0; i < 100; i++) { value = somearray[i]; } 

o

 for (var i = 0 ; i < 100; i++) { var value = somearray[i]; } 

Non c’è assolutamente alcuna differenza di significato o prestazioni, in JavaScript o ActionScript.

var è una direttiva per il parser e non un comando eseguito in fase di esecuzione. Se un identificatore particolare è stato dichiarato var una o più volte in un corpo della funzione (*), allora tutto l’uso di quell’identificatore nel blocco si riferirà alla variabile locale. Non fa differenza se il value è dichiarato essere var all’interno del ciclo, fuori dal ciclo o entrambi.

Di conseguenza dovresti scrivere quello che trovi più leggibile. Non sono d’accordo con Crockford che mettere tutti i vars nella parte superiore di una funzione è sempre la cosa migliore. Nel caso in cui una variabile venga usata temporaneamente in una sezione di codice, è meglio dichiarare var in quella sezione, quindi la sezione è isolata e può essere copiata. Altrimenti, copia-incolla alcune righe di codice in una nuova funzione durante il refactoring, senza selezionare separatamente e spostando la var associata, e ti sei procurato un globale accidentale.

In particolare:

 for (var i; i<100; i++) do something; for (var i; i<100; i++) do something else; 

Crockford ti consiglierà di rimuovere la seconda var (o rimuovere sia var s che do var i; sopra), e jslint ti piagnucolerà per questo. Ma IMO è più manutenibile per mantenere entrambe le var , mantenendo insieme tutto il codice correlato, invece di avere un bit di codice in più, facilmente dimenticato nella parte superiore della funzione.

Personalmente tendo a dichiarare come var il primo assegnamento di una variabile in una sezione di codice indipendente, indipendentemente dal fatto che ci sia o meno un altro uso separato dello stesso nome di variabile in qualche altra parte della stessa funzione. Per me, dover dichiarare var è una verruca JS non desiderabile (sarebbe stato meglio avere le variabili come predefinite in locale); Non vedo come mio dovere duplicare le limitazioni di [una vecchia revisione di] ANSI C anche in JavaScript.

(*: diverso da corpi funzione nidificati)

In teoria non dovrebbe fare alcuna differenza in JavaScript, dal momento che il linguaggio non ha scope di blocco, ma solo scope di funzione.

Non sono sicuro dell’argomento sulle prestazioni, ma Douglas Crockford raccomanda ancora che le istruzioni var siano le prime dichiarazioni nel corpo della funzione. Citando da Convenzioni di codice per il linguaggio di programmazione JavaScript :

JavaScript non ha scope di blocco, quindi la definizione di variabili in blocchi può confondere i programmatori che hanno esperienza con altri linguaggi di famiglia C. Definire tutte le variabili nella parte superiore della funzione.

Penso che abbia un punto, come puoi vedere nel seguente esempio. Dichiarare le variabili nella parte superiore della funzione non dovrebbe confondere i lettori nel pensare che la variabile i sia tenuta nell’ambito del blocco del ciclo for :

 function myFunction() { var i; // the scope of the variables is very clear for (i = 0; i < 10; i++) { // ... } } 

La lingua ECMA-/Javascript qualsiasi variabile che è dichiarata ovunque nella parte superiore di una funzione. Questo perché questo linguaggio ha function scope e non ha block scope come molti altri linguaggi simili a C.
Questo è anche noto come lexical scope .

Se dichiari qualcosa del genere

 var foo = function(){ for(var i = 0; i < 10; i++){ } }; 

Questo viene hoisted a:

 var foo = function(){ var i; for(i = 0; i < 10; i++){ } } 

Quindi non fa alcuna differenza nelle prestazioni (ma correggimi se ho torto completamente qui).
Un argomento molto migliore per non dichiarare una variabile da qualche altra parte rispetto alla parte superiore di una funzione è la leggibilità . Dichiarare una variabile all'interno di un for-loop può portare all'assunzione errata che questa variabile possa essere raggiunta solo all'interno del corpo del ciclo, il che è completamente sbagliato . Infatti è ansible accedere a tale variabile ovunque all'interno dello scope corrente.

L’anno prossimo, tutti i browser avranno motori JS che precompilano il codice in modo tale che la differenza di prestazioni (che deriva dall’analisi più e più volte dello stesso blocco di codice più l’esecuzione del compito) diventi trascurabile.

Inoltre, non ottimizzare mai le prestazioni a meno che non sia necessario. Mantenere le variabili vicino al luogo in cui ti servono la prima volta mantiene pulito il tuo codice. Sul lato negativo, le persone che sono abituate alle lingue con gli ambiti a blocchi potrebbero essere confuse.

Ho appena fatto un semplice test in Chrome. Prova il violino nel tuo browser e guarda i risultati

  var count = 100000000; var a = 0; console.log(new Date()); for (var i=0; i 

Il risultato è che l'ultimo test dura circa 8 secondi e che i 2 precedenti sono solo ~ 2 secondi. Molto ripetibile e indipendentemente dall'ordine.

Quindi, questo dimostra che dovrei sempre dichiarare i vars fuori dal giro. Il caso curioso per me è il primo in cui dichiaro i nella dichiarazione for (). Questo sembra essere altrettanto veloce del secondo test in cui dichiaro l'indice.

Un’altra considerazione, ora che abbiamo let e const in ES2015, è che ora puoi eseguire il scope delle variabili in modo specifico sul blocco del ciclo. Quindi, a meno che non sia necessaria la stessa variabile al di fuori del ciclo (o se ogni iterazione dipende da un’operazione eseguita su quella variabile nella precedente iterazione), è probabilmente preferibile farlo:

 for (let i = 0; i < 100; i++) { let value = somearray[i]; //do something with `value` } 

JavaScript è una lingua scritta in basso da C o C ++, non sono molto sicuro di quale sia. E uno dei suoi scopi è salvare il stream di gestione della memoria interna. Anche in C o C ++, non dovrai preoccuparti se consumerà molte risorse quando le variabili vengono dichiarate all’interno di un ciclo. Perché dovresti preoccuparti di ciò in JavaScript?

Beh, questo dipende da cosa stai cercando di ottenere … se il value suppone di essere solo una variabile temporanea all’interno del blocco del ciclo, allora è molto più chiaro usare il secondo modulo. È anche più logico e dettagliato.

Non fa differenza se si dichiarano variabili all’interno o all’esterno di for loop. Di seguito è riportato il codice di esempio da testare.

 function a() { console.log('Function a() starts'); console.log(new Date()); var j; for (j=0; j<100000000; j++) { var x; x = x + 1; } console.log(new Date()); console.log('Function a() Ends'); } a() function b() { console.log('Function B() starts'); console.log(new Date()); var a; var j; for (j=0; j<100000000; j++) { a = a + 1; } console.log(new Date()); console.log('Function B() Ends'); } b() 

I risultati hanno mostrato nel mio caso

 Function a() starts VM121:3 Thu Apr 12 2018 15:20:26 GMT+0530 (India Standard Time) VM121:9 Thu Apr 12 2018 15:20:26 GMT+0530 (India Standard Time) VM121:10 Function a() Ends VM121:14 Function B() starts VM121:15 Thu Apr 12 2018 15:20:26 GMT+0530 (India Standard Time) VM121:21 Thu Apr 12 2018 15:20:26 GMT+0530 (India Standard Time) VM121:22 Function B() Ends 

Grazie - MyFavs.in

La domanda qui è fondamentalmente quella di dichiarare una var all’interno di un ciclo. Pensa cosa succede se lo fai:

 var a = 30; var a = 50; var a = 60; 

Pensi che sia giusto? No … perché non vuoi dichiarare una variabile così tante volte. Quando dichiari una variabile all’interno di un ciclo, non sta dichiarando tutte le volte che il ciclo viene eseguito? Ovviamente ti darà uno schiaffo quando sei in modalità ‘uso rigoroso’. Le persone non sono d’accordo con Crockford senza pensare alla domanda originale.

Quindi è sempre bene dichiarare le variabili in cima: 1. Per la leggibilità, 2. Fare buone abitudini.

Per quanto riguarda le prestazioni dopo il test di esecuzione su Chrome, Firefox e jsperf su un sistema operativo Linux, sembra esserci una differenza di prestazioni tra la dichiarazione delle variabili in un ciclo e fuori dal ciclo. È una piccola differenza, ma è anche complicata dalla quantità di iterazioni e dalla quantità di dichiarazioni variabili.

Pertanto, per ottenere prestazioni ottimali, dovrei suggerire di dichiarare le variabili al di fuori del ciclo. O meglio ancora, dichiarare le variabili in linea. Vedi esempio.

 // inline for (var ai = 0, al = 100000000, av; ai < al; ai++) { av = av + 1; } // outside var bv; var bl = 100000000; for (var bi = 0; bi < bl; bi++) { bv = bv + 1; } 

Si noti come la variabile 'al' e 'av' siano nella riga di dichiarazione del ciclo for. Questa dichiarazione in linea mi ha fornito prestazioni sempre migliori. Anche oltre la dichiarazione delle variabili al di fuori del ciclo. Ancora una volta la differenza di prestazioni è davvero piccola.

https://jsperf.com/outside-inline-for-loop-ase/1