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

Ho scritto molto codice ES6 per io.js di recente. Non c'è molto codice in natura da cui imparare, quindi mi sento come se stessi definendo le mie convenzioni.

La mia domanda è su quando utilizzare constvs let.

Ho applicato questa regola: se possibile, utilizzare const. Utilizzare solo letse si conosce che il suo valore deve cambiare. (Puoi sempre tornare indietro e cambiare a constin a letse in seguito si scopre che è necessario modificarne il valore.)

Il motivo principale di questa regola è che è facile da applicare in modo coerente. Non ci sono aree grigie.

Il fatto è, quando applico questa regola, in pratica il 95% delle mie dichiarazioni lo sono const. E questo mi sembra strano. Sto solo usando letcose come iin un forciclo, o occasionalmente per cose come i totali di Fibonacci accumulati (che non si presentano molto nella vita reale). Sono rimasto sorpreso da questo: risulta che il 95% delle "variabili" nel mio codice ES5 fino ad oggi erano per valori che non variano. Ma vedere in consttutto il mio codice mi sembra sbagliato in qualche modo.

Quindi la mia domanda è: va bene usare constcosì tanto? Dovrei davvero fare cose del genere const foo = function () {...};?

O dovrei riservarmi constper quel tipo di situazioni in cui stai codificando un letterale nella parte superiore di un modulo - il tipo che fai in maiuscolo, come const MARGIN_WIDTH = 410;?

La mia risposta qui non è specifica per JavaScript.

Come regola empirica in qualsiasi lingua che mi consenta di farlo in modo semi-semplice, direi sempre di usare const / final / readonly / qualunque cosa venga chiamata nella tua lingua ogni volta che è possibile. Il motivo è semplice, è molto più facile ragionare sul codice quando è ovvio cosa può cambiare e cosa non può cambiare. Inoltre, in molte lingue puoi ottenere il supporto degli strumenti che ti dice che stai facendo qualcosa di sbagliato quando assegni accidentalmente una variabile che hai dichiarato const.

Tornare indietro e cambiare una const in una let è semplicissimo. E andare const di default ti fa pensare due volte prima di farlo. E questo è in molti casi una buona cosa.

Quanti bug hai riscontrato che le variabili coinvolte cambiano inaspettatamente? Immagino molto. So che la maggior parte dei bug che vedo coinvolgono cambiamenti di stato inaspettati. Non ti libererai di tutti questi bug usando liberamente const, ma ti sbarazzerai di molti di loro!

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

E tutto inizia con l'essere estremamente liberale con const! ;) Sono solo altri due personaggi da scrivere rispetto a let, quindi vai avanti e consttutto il resto!

Fai attenzione, perché constle chiavi degli oggetti sono modificabili.

Da qui: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/const

le chiavi degli oggetti non sono protette

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 prendendo in considerazione l'utilizzo constper tutti i non array / non oggetti e l'uso letper oggetti / array.

Non ti preoccupare. constè un'aggiunta straordinaria a JavaScript e ti consiglierei di usarlo in tutti i posti che ha senso. Rende il codice più robusto.

Quando si tratta di oggetti, constproteggerai la tua variabile dalla riassegnazione, ma se hai bisogno di oggetti immutabili, avrai bisogno del Object.freezemetodo, vedi sotto.

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

constproteggerà solo dalla riassegnazione e il freezemetodo proteggerà tutte le proprietà immediate. Se è necessario che anche tutte le proprietà nidificate siano immutabili, è necessario ricorsivamente freeze.

Nel mio ES6 constnon si tratta di post sull'immutabilità , spiego cosa constsignifica esattamente secondo le specifiche.

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

[…] Ha senso usare lete constcome segue nel tuo codice ES6:

• utilizzare constper impostazione predefinita
• utilizzare solo letse è necessario il rebinding (ovvero qualsiasi forma di riassegnazione)
• ( varnon dovrebbe essere usato in ES6)

Per quanto soggettivo, è un dato di fatto che questo corrisponde più da vicino alle intenzioni della specifica.

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

Usare constsolo per le costanti è come usare l' <aside>elemento HTML solo per il contenuto della 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 sola riga e non modificate dopo. Generalmente quelle variabili che sono lì solo per ridurre la quantità di battitura. Per 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]
  ...
}

constper tutti i nomi noti per essere costanti in tutto il modulo. Non inclusi i valori di costante locale. L' valueesempio sopra, ad esempio, ha una portata costante e potrebbe essere dichiarato 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 valuesia sempre lo stesso. I moduli e le funzioni sono il miglior esempio di constvariabili:

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

varper tutto ciò che può essere o meno variabile. I nomi che possono confondere le persone che leggono il codice, anche se sono costanti a livello locale e per i quali non sono adatti let(ovvero non sono completati in una semplice dichiarazione diretta), si applicano per essere dichiarati con var. Per 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 futuri aggiornamenti qui .

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

const public void DoSomething()

Il constè dispari, e questo perché le dichiarazioni di metodo in queste lingue non possono cambiare, una volta che sono compilati in qualcosa d'altro, che è quello che fanno, non importa quale (ignorando alcuni hack orribili che possono esistere).

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