Pillole di codice #8 ECMA Script6: var, let e const

Siamo sempre stati abituati in Javascript a usare var come dichiaratore per le variabili.

Javascript non essendo un linguaggio fortemente tipizzato ci permette quindi di dichiarare tutto come “var” generica e poi assegnargli un valore, in quel momento la variabile viene identificata come stringa, oggetto, intero, etc.

Chi stabilisce le regole generali del linguaggio è un ente: Ecma International che definisce gli standard di comunicazione che devono avere un set di linguaggi di programmazione (tecnicamente dialetti), tra i quali troviamo: JavaScript, JScript, ActionScript e molti altri.

JavaScript è il linguaggio di programmazione che più si adatta alle direttive ECMA e nello scorso anno (il 2017) tutti i browser principali si sono adattati alla nuova release di JavaScript che utilizza gli standard EcmaScript6 (meglio conosciuto come ES6).

Di tutte le novità introdotte ce ne sono 2 particolarmente importanti che è necessario mettere in evidenza: l’introduzione di let e const.

Let e Const non sono altro che i nuovi modi di definire variabili e costanti in JavaScript.

Per capire l’importanza di queste due nuove entità è necessario comprendere a pieno cosa avevamo in mano prima della loro introduzione.

Per definire una variabile prima dell’introduzione di ES6 ci bastava usare il termine var, che però nella sua intrinseca semplicità si portava dietro alcuni difetti, uno su tutti era la visibilità a funzione (function scope).

Ad esempio scrivendo questo codice:

function qualcosa(){
   //codice vario
   if (condizione){
      var pippo=0;
   }
   //ancora codice
   if (condizione2){
      var paperino=1;
   }
}

L’interprete agiva nel seguente modo:

function qualcosa(){
   var pippo;
   var paperino;
   //codice vario
   if (condizione){
      pippo=0;
   }
   //ancora codice
   if (condizione2){
      paperino=1;
   }
}

In apparenza la logica è sostanzialmente la stessa, ma l’arte della programmazione necessita di standard di comunicazione estremamente restrittivi, per ottenere la massima efficacia dal punto di vista operativo.

Può capitare infatti che un programmatore distratto (in gergo: spaghettaro) vada a scrivere le variabili pippo e paperino (con una banale assegnazione) prima della loro dichiarazione.

Il programma in questo caso scrive e lavora normalmente sulla variabile senza creare errori, fino a porre un reset nella linea della dichiarazione.

Infatti fino a poco tempo fa in Javascript era buona norma di uso comune dichiarare tutte le variabili ad inizio funzione, per poi usarle in seguito, evitando così errori di sorta.

Let ci viene incontro per questo genere di problemi, infatti let ha una visibilità di blocco (block scope).

Una variabile dichiarata con let nasce e muore nel suo blocco di parentesi grafe (aiutandoci inoltre con la gestione della memoria in caso di software complessi).

L’esempio di prima riscritto usando let al posto di var diventerebbe quindi:

function qualcosa(){
   //codice vario
   if (condizione){
      let pippo=0;
   }
   //ancora codice
   if (condizione2){
      let paperino=1;
   }
}

E di conseguenza l’interprete agirebbe nel seguente modo:

function qualcosa(){
   //codice vario
   if (condizione){
      let pippo;
      pippo=0;
   }
   //ancora codice
   if (condizione2){
      let paperino;
      paperino=1;
   }
}

Riducendo notevolmente le possibilità di creare errori, e aiutandoci ad ottimizzare la gestione della memoria (cosa assai difficile da fare in un linguaggio interpretato [logan-icon icon=”logan-icon-misc-smilehappymood”]).

Const oltre ad avere gli stessi pregi di visibilità di let ci permette di proteggere una variabile rendendola immune alla scrittura ottenendo quindi una costante.

Sembra quasi impossibile ma le costanti fino a poco fa non esistevano in javascript e per ottenerle bisognava creare degli oggetti custom che nella loro dichiarazione avessero la “writabilità” (il parametro writable) impostato a false.

Ora il costrutto const ci permette di avere costanti da utilizzare liberamente nel nostro codice senza la paura di dover fare attenzione (anche se l’attenzione assieme ad una buona progettazione dovrebbe sempre esserci quando si programma) a non riscriverle accidentalmente.

Quindi regola generale da tenere sempre a mente: dimentichiamoci di var e usiamo solo let e const quando scriviamo i nostri programmi in JavaScript.

Ecco il video della pillola

Compila il form qui sotto per ricevere subito nella tua casella email i files della lezione.