Quanto dovrei usare 'let' vs 'const' in ES6?

La mia risposta qui non è specifica per javascript.

Come regola empirica in qualsiasi lingua che mi permetta di farlo in un modo semi-facile direi sempre usare const / final / readonly / qualunque sia chiamato nella tua lingua ogni volta che è possibile. La ragione è semplice, è molto più facile ragionare sul codice quando è ovvio che cosa può cambiare e cosa non può cambiare. In aggiunta a questo, in molte lingue puoi ottenere il supporto degli strumenti che ti dice che stai facendo qualcosa di sbagliato quando assegni accidentalmente a una variabile che hai dichiarato come const.

Ritornare e cambiare un const in let è semplice. E andando const di default ti fa pensare due volte prima di farlo. E questo è in molti casi una buona cosa.

Quanti bug hai visto che coinvolgono variabili che cambiano in modo imprevisto? Direi molto. So che la maggior parte degli errori che vedo coinvolgono cambiamenti di stato imprevisti. Non ti libererai di tutti questi bug usando liberamente const, ma ne libererai molti!

Inoltre, molti linguaggi funzionali hanno variabili immutabili in cui tutte le variabili sono const per default. Guarda ad esempio Erlang o F #. La codifica senza assegnazione funziona perfettamente in queste lingue ed è uno dei tanti motivi per cui la gente ama la programmazione funzionale. C'è molto da imparare da questi linguaggi sulla gestione dello stato per diventare un programmatore migliore.

E tutto inizia con l'essere estremamente liberale con const! ;) Ci sono solo due caratteri in più da scrivere rispetto a let, quindi vai avanti e const tutte le cose!

Fai attenzione, perché le chiavi dell'oggetto const sono modificabili.

Da qui: link

object keys are not protected

considera questo esempio:

const colors = {red: "#f00"}; 
console.log(colors); // { "red": "#f00" }

colors.red = "#00f";
colors.green = "#0f0";
console.log(colors); // { "red": "#00f", "green": "#0f0" }

Stessa cosa per gli array:

const numbers = [1, 2, 3];
console.log(numbers); // [ 1, 2, 3 ]

numbers.push(4);
console.log(numbers); // [ 1, 2, 3, 4 ]

Non ho deciso totalmente me stesso, ma sto considerando di usare const per tutti i non-array / non-oggetti e usare let per oggetti / array.

Non ti preoccupare. const è una straordinaria aggiunta a JavaScript e ti consiglierei di utilizzarla in tutti i luoghi che ha senso. Rende il codice più robusto.

Quando si tratta di oggetti, const proteggerà la tua variabile dalla riassegnazione, ma se hai bisogno di oggetti immutabili, avrai bisogno del metodo Object.freeze , vedi sotto.

const immutableOject = Object.freeze({immutableProperty: 'foo'});

const proteggerà solo dalla riassegnazione e il metodo freeze proteggerà tutte le proprietà immediate. Se hai bisogno che tutte le proprietà annidate siano immutabili, dovrai ricorsivamente freeze di esse.

Nel mio ES6% diconst non riguarda l'immutabilità post, spiego cosa const significa esattamente in base alle specifiche.

Sulla base di questi fatti oggettivi, ecco la mia preferenza personale:

[…] it makes sense to use let and const as follows in your ES6 code:

• use const by default
• only use let if rebinding (i.e. any form of reassignment) is needed
• (var shouldn’t be used in ES6)

Per quanto soggettivo possa essere, è un dato di fatto che questo corrisponda maggiormente all'intento della specifica.

Le persone che utilizzano let per impostazione predefinita di solito trattano le variabili const come costanti (che non sono necessariamente, in base alla progettazione!). A ciascuno il suo, ma preferisco usare le cose per il loro scopo previsto, e non per qualche significato inventato che le persone assegnano ad esso in base a un malinteso.

L'uso di const solo per le costanti è come utilizzare l'HTML% elemento_demento% solo per contenuto barra laterale.

Il mio approccio personale, pensato per aiutare la leggibilità e la comprensione del codice:

let è solo per variabili di breve durata, definite su una singola riga e non modificate dopo. Generalmente quelle variabili che ci sono solo per diminuire la quantità di digitazione. Ad esempio:

for (let key in something) {
  /* we could use 'something[key]' for this entire block,
     but it would be too much letters and not good for the
     fingers or the eyes, so we use a radically temporary variable
  */
  let value = something[key]
  ...
}

const per tutti i nomi noti per essere costanti in tutto il modulo. Non includendo valori costanti localmente. La value nell'esempio sopra, ad esempio, è costante nel suo ambito e potrebbe essere dichiarata con const , ma poiché ci sono molte iterazioni e per ognuna c'è un valore con lo stesso nome , "valore", che potrebbe indurre il lettore a pensare che value sia sempre lo stesso. I moduli e le funzioni sono il miglior esempio di const variabili:

const PouchDB = require('pouchdb')
const instantiateDB = function () {}
const codes = {
  23: 'atc',
  43: 'qwx',
  77: 'oxi'
}

var per tutto ciò che può essere o non essere variabile. I nomi che possono confondere le persone che leggono il codice, anche se sono costanti localmente e non sono adatti per let (vale a dire, non sono compilati in una semplice dichiarazione diretta) si applicano per essere dichiarati con var . Ad esempio:

var output = '\n'
lines.forEach(line => {
  output += '  '
  output += line.trim()
  output += '\n'
})
output += '\n---'

for (let parent in parents) {
  var definitions = {}
  definitions.name = getName(parent)
  definitions.config = {}
  definitions.parent = parent
}

Ulteriori commenti e possibili aggiornamenti futuri qui .

JavaScript è un po 'speciale in quanto le variabili possono essere funzioni e simili, ma considerate in C #, Java o un altro linguaggio in stile C simile:

const public void DoSomething()

La const è dispari, e questo perché le dichiarazioni di metodo in queste lingue non possono cambiare, una volta che sono compilate in qualcos'altro, questo è quello che fanno, indipendentemente da cosa (ignorando alcuni hack orribili che possono esistere).

Perché JavaScript dovrebbe essere diverso? Quindi non è compilato, ma ciò non significa che dovremmo gettare via la sicurezza che i compilatori possono fornire. L'uso della parola chiave const ci dà più sicurezza, il che sicuramente porterà a applicazioni più solide.