C'è qualche ragione per usare la parola chiave "var" in ES6?

Doug Crockford discute di let a questo punto nel suo discorso, "Le parti migliori ".

Il punto è, let evita una fonte di malintesi, esp. per programmatori con aspettative impostate in lingue con ambito di blocco. Un var ha ambito di funzione (dichiara una variabile visibile in tutta la funzione) anche se sembra come se avesse ambito di blocco .

var potrebbe essere ancora utile in casi estremi come il codice generato dalla macchina, ma mi sto impegnando molto.

( const è anche nuovo e ha scope block. Dopo let x = {'hi': 'SE'} puoi riassegnare a x , mentre dopo const y = x non puoi riassegnare a y . Spesso è preferibile in quanto impedisce che qualcosa cambi accidentalmente fuori da sotto di te. Ma per essere chiari, puoi comunque modificare l'oggetto y.hi = 'SO' a meno che non lo blocchi.)

Realisticamente, la tua impressione è corretta per ES6: Adotta let e const . Smetti di usare var .

(In un'altra performance di "The Better Parts" , Doug dice perché === è stato aggiunto piuttosto che risolvendo i problemi di == . == produce alcuni risultati "sorprendenti", quindi basta adottare === .)

Un esempio rivelatore

Mozilla Developer Network fornisce un esempio in cui var non funziona come previsto. Il loro esempio è realistico che imposta onclick gestori in una pagina web. Ecco un piccolo test case:

var a = [];
(function () {
   'use strict';
   for (let i = 0; i < 5; ++i) { // *** 'let' works as expected ***
     a.push( function() {return i;} );
   }
} ());
console.log(a.map( function(f) {return f();} ));
// prints [0, 1, 2, 3, 4]

// Start over, but change 'let' to 'var'.
// prints [5, 5, 5, 5, 5]

var ci fallisce perché tutte le iterazioni del ciclo condividono la stessa variabile i con scope della funzione, che ha il valore 5 dopo il termine del ciclo.

Se hai scritto codice corretto, probabilmente sarai in grado di trasformare tutte le istruzioni var in istruzioni let senza modifiche semantiche.

let è preferibile perché riduce l'ambito in cui un identificatore è visibile. Ci consente di dichiarare in modo sicuro le variabili nel sito di primo utilizzo.

const è preferibile a let . A meno che non sia necessario modificare un riferimento, utilizzare una dichiarazione const . Questo ha tutti i benefici di let e riduce la presenza di variabili unitializzate e rende il codice generalmente più facile da ragionare. Se non sei sicuro di dover modificare un riferimento, dichiaralo const finché non ti trovi esplicitamente a doverlo fare.

Non penso necessariamente che tu stia sbagliando, ma ci sono avvertenze sull'uso di var. In sostanza, let dovrebbe aiutare gli sviluppatori a superare la stupidità di JavaScript, in particolare con i conflitti di denominazione. var , a quanto pare, ha uno scope più grande dal momento che vuole andare allo scope scope della funzione. Ci saranno momenti in cui hai bisogno di var, come quando hai bisogno di una variabile temporanea per essere disponibile nell'ambito di un blocco all'interno di una funzione, altrimenti, preferendo let su var aiuterà gli sviluppatori a risolvere i conflitti di denominazione. Su una nota più leggera, è giunto il momento che ES6 abbia introdotto let .

Sono tendenzialmente d'accordo che solo "let" dovrebbe essere usato in es6. AFIK, ridichiarare un "let" genera un errore (che è buono), mentre con "var", basta semplicemente sovrascrivere il valore (anche se "strict mode" in es5 si occupa anche di questo).

let significa "lascia la variabile uguale". È una dichiarazione, in altre parole, un'inizializzazione e un incarico.

Esiste in contrasto con const che ovviamente significa "costante" - che è l'opposto della variabile.

Alcune altre lingue usano un prefisso all'oggetto reale anziché l'oggetto quando lo dichiarano (es. def è una scorciatoia per "define function" - manca completamente il punto di ciò che è "def".

Let aggiunge questa incoerenza semantica a Javascript.

Logicamente, potresti anche lasciare una costante uguale a qualcosa, dato che il lavoro della parola chiave "let" è di assegnare memoria.

Il problema sorge perché la parola chiave var è stata introdotta prima che const fosse supportata, quindi la compatibilità all'indietro impone che var non significhi necessariamente una variabile. (Potrebbe anche essere usato per assegnare un valore costante.)

Quindi, l'introduzione di let nella posizione sbagliata. Per essere sicuri di ricordare che in modo lessicale, questo è sbagliato, hanno anche deciso di modificare lo scope lessicale di let rispetto a var , quindi l'incoerenza è in primo piano nelle nostre menti durante il debug.

In altre parole, let esiste perché le persone (ovvero i manutentori della lingua) pensavano che Javascript fosse troppo coerente, avendo padroneggiato tutti i suoi idiomi e idiosincrasie, desiderando di più.

Nota laterale, var non funziona nei blocchi "freccia" se vuoi trattare i blocchi come chiusure (perché var è stato introdotto prima del trattamento dei blocchi come chiusure), ma let lo fa.