Uso corretto di const per la definizione di funzioni in JavaScript

Sono interessato se ci sono dei limiti a quali tipi di valori possono essere impostati usando const in JavaScript, in particolari funzioni. È valido? Certo che funziona, ma è considerato una ctriggers pratica per qualsiasi motivo?

 const doSomething = () => { ... } 

Tutte le funzioni dovrebbero essere definite in questo modo in ES6? Non sembra che questo sia accaduto, se è così.

Grazie per eventuali commenti!

Non c’è alcun problema con quello che hai fatto, ma devi ricordare la differenza tra le dichiarazioni di funzione e le espressioni di funzione.

Una dichiarazione di funzione, ovvero:

 function doSomething () {} 

È issato interamente nella parte superiore dell’ambito (e come let e const sono anche a livello di blocco).

Ciò significa che quanto segue funzionerà:

 doSomething() // works! function doSomething() {} 

Un’espressione di funzione, ovvero:

 [const | let | var] = function () {} (or () => 

È la creazione di una funzione anonima ( function () {} ) e la creazione di una variabile, e quindi l’assegnazione di quella funzione anonima a quella variabile.

Quindi le solite regole attorno al sollevamento di variabili all’interno di un ambito – variabili con scope a blocchi ( let e const ) non vengono issate come undefined nella parte superiore del loro ambito di blocco.

Questo significa:

 if (true) { doSomething() // will fail const doSomething = function () {} } 

doSomething poiché doSomething non è definito. (Lancia un ReferenceError )

Se si passa a usare var si ottiene il sollevamento della variabile, ma verrà inizializzato a undefined modo che il blocco di codice sopra non funzioni ancora. (Questo genererà un TypeError poiché doSomething non è una funzione al momento in cui viene chiamato)

Per quanto riguarda le pratiche standard, è necessario utilizzare sempre lo strumento adeguato per il lavoro.

Axel Rauschmayer ha un ottimo post su scope e sollevamento inclusa la semantica es6: Variabili e Scoping in ES6

Anche se usare const per definire le funzioni sembra un hack, ma ha alcuni grandi vantaggi che lo rendono superiore (secondo me)

  1. Rende immutabile la funzione, quindi non devi preoccuparti che la funzione venga modificata da qualche altra parte di codice.

  2. È ansible utilizzare la syntax della freccia grossa, che è più breve e più pulita.

  3. Usando le funzioni di freccia si prende cura di this vincolante per te.

esempio con la function

 // define a function function add(x, y) { return x + y; } // use it console.log(add(1, 2)); // 3 // oops, someone mutated your function add = function (x, y) { return x - y; }; // now this is not what you expected console.log(add(1, 2)); // -1 

Ci sono alcuni vantaggi molto importanti per l’uso di const e alcuni direbbero che dovrebbe essere usato ovunque ansible a causa di quanto sia intenzionale e indicativo.

È, per quanto posso dire, la dichiarazione più indicativa e prevedibile delle variabili in JavaScript, e una delle più utili, PERCHÉ di quanto sia limitato. Perché? Perché elimina alcune possibilità disponibili per var e let dichiarazioni.

Cosa puoi dedurre quando leggi un const ? Si conosce tutto ciò che segue semplicemente leggendo la dichiarazione della dichiarazione const , E senza eseguire la scansione per altri riferimenti a quella variabile:

  • il valore è legato a quella variabile (sebbene il suo object sottostante non sia profondamente immutabile)
  • non è ansible accedervi al di fuori del suo blocco immediatamente contenente
  • il binding non viene mai utilizzato prima della dichiarazione, a causa delle regole della zona morta temporanea (TDZ).

La seguente citazione proviene da un articolo che sostiene i vantaggi di let e const . Inoltre, risponde più direttamente alla tua domanda relativa ai vincoli / limiti della parola chiave:

Vincoli come quelli offerti da let e const sono un modo potente per rendere il codice più facile da capire. Cerca di accumulare quanti più limiti ansible nel codice che scrivi. I vincoli più dichiarativi che limitano ciò che un pezzo di codice potrebbe significare, più facile e veloce è per gli esseri umani leggere, analizzare e capire un pezzo di codice in futuro.

Certo, ci sono più regole per una dichiarazione const rispetto a una dichiarazione var : scope-scope, TDZ, assegna alla dichiarazione, nessuna riassegnazione. Mentre le istruzioni var segnalano solo lo scope delle funzioni. Il conteggio delle regole, tuttavia, non offre molte informazioni. È meglio valutare queste regole in termini di complessità: la regola aggiunge o sottrae complessità? Nel caso di const , scope scope significa un ambito più ristretto rispetto all’ambito della funzione, TDZ significa che non è necessario analizzare l’ambito indietro dalla dichiarazione per individuare l’utilizzo prima della dichiarazione e le regole di assegnazione significano che il binding conserverà sempre lo stesso riferimento.

Più le dichiarazioni sono vincolate, più semplice diventa una parte di codice. Quando aggiungiamo dei vincoli a ciò che potrebbe significare una dichiarazione, il codice diventa meno imprevedibile. Questo è uno dei principali motivi per cui i programmi con tipizzazione statica sono generalmente più facili da leggere rispetto a quelli tipizzati dynamicmente. La tipizzazione statica pone un grosso limite allo scrittore del programma, ma pone anche un grosso limite su come interpretare il programma, rendendo più comprensibile il suo codice.

Tenendo presente questi argomenti, si consiglia di utilizzare const laddove ansible, in quanto è l’affermazione che ci offre le minori possibilità di pensare.

Fonte: https://ponyfoo.com/articles/var-let-const

Sono passati tre anni da quando è stata posta questa domanda, ma ora lo sto incontrando. Dal momento che questa risposta è così in basso, per favore permettimi di ripeterla:

D: Sono interessato se ci sono dei limiti su quali tipi di valori possono essere impostati usando const in JavaScript – in particolari funzioni. È valido? Certo che funziona, ma è considerato una ctriggers pratica per qualsiasi motivo?

Ero motivato a fare delle ricerche dopo aver osservato un prolifico codificatore JavaScript che usa sempre la dichiarazione const per le functions , anche quando non vi è alcun motivo / beneficio apparente.

In risposta a ” è considerata una ctriggers pratica per qualsiasi motivo? “, Lasciami dire, IMO, sì lo è, o almeno, ci sono dei vantaggi nell’usare la dichiarazione di function .

Mi sembra che questo sia in gran parte una questione di preferenza e stile. Ci sono alcuni buoni argomenti presentati sopra, ma nessuno così chiaro come è fatto in questo articolo:

Confusione costante: perché uso ancora le dichiarazioni delle funzioni JavaScript di medium.freecodecamp.org/Bill Sourour, guru JavaScript, consulente e insegnante.

Invito tutti a leggere quell’articolo, anche se hai già preso una decisione.

Ecco i punti principali:

Le istruzioni di funzione hanno due evidenti vantaggi rispetto alle espressioni di funzione [const]:

Vantaggio n. 1: chiarezza d’intenti

Quando si analizzano migliaia di righe di codice al giorno, è utile essere in grado di capire l’intento del programmatore nel modo più rapido e semplice ansible.

Vantaggio 2: ordine di dichiarazione == ordine di esecuzione

Idealmente, voglio dichiarare il mio codice più o meno nell’ordine in cui prevedo che verrà eseguito.

Questo è lo showstopper per me: qualsiasi valore dichiarato usando la parola chiave const è inaccessibile finché l’esecuzione non lo raggiunge.

Quello che ho appena descritto sopra ci costringe a scrivere codice che sembra sottosopra. Dobbiamo iniziare con la funzione di livello più basso e procedere verso l’alto.

Il mio cervello non funziona in questo modo. Voglio il contesto prima dei dettagli.

La maggior parte del codice è scritta da umani. Quindi ha senso che l’ordine di comprensione della maggior parte delle persone segua approssimativamente l’ordine di esecuzione del codice.

C’è un altro scenario in cui una funzione costante potrebbe essere utile. Se hai molte costanti nel tuo codice e hai bisogno di una funzione che funzioni specificamente su quelle costanti, potrebbe essere una buona idea trasformare quella funzione in una costante stessa:

 const FLAG_ONE = 1; const FLAG_TWO = 2; const FLAG_THREE = 4; // etc. // resolves flag into string for debugging purposes: const FLAG_NAME = flag => { switch ( flag ) { case FLAG_ONE: return 'one'; // etc. } }; 

Non è necessario in alcun modo definire FLAG_NAME come costante, ma migliorerà la leggibilità del tuo codice per farlo.