MDN’s new design is in Beta! A sneak peek: https://blog.mozilla.org/opendesign/mdns-new-design-beta/

Questa traduzione è incompleta. Collabora alla traduzione di questo articolo dall’originale in lingua inglese.

Descrizione

Dichiara il blocco della visibilità di una variabile e/o la inizializza ad un nuovo valore.

Sintassi

let definizione:

let var1 [= value1] [, var2 [= value2]] [, ..., varN [= valueN]];

let expressione:

let (var1 [= value1] [, var2 [= value2]] [, ..., varN [= valueN]]) expression;

let assegnamento:

let (var1 [= value1] [, var2 [= value2]] [, ..., varN [= valueN]]) statement;

Parametri

Parametri Descrizione
var1, var2, …, varN Nome della variabile. Qualunque nome valido va bene.
value1, value2, …, valueN Valore iniziale della variabile.  Qualunque espressione valida va bene.
expression Qualunque espressione valida.
statement Qualunque assegnamento valido.

Descrizione

let permette di dichiarare variabili limitandone la visibilità ad un blocco di codice, ad un assegnazione, ad un espressione in cui è usata. Contratiamente alla parola chiave var, che invece definisce una variabile globalmente in uno script o localmente in un qualunque blocco di codice di una funzione.

Blocco della visibilità

Le variabili inizializzate da let sono legate al blocco dell'espressione in cui sono dichiarate.

Dichiarare nuovamente la stessa variabile con let restituisce l'errore TypeError.


if (x) {
  let foo;
  let foo; // TypeError thrown.
}

Nelle funzioni invece non ci sono limiti ai riassegnamenti.


function do_something() {
  let foo;
  let foo; // This works fine.
}
Attenzione: ECMAScript 6 (a partire da Aprile, 2012) rende illegale questo tipo di comportamento. Ciò significa che le future versioni di JavaScript saranno probabilmente allineate e genereranno un TypeError se utilizzerai questa prassi!

Potresti imbatterti in errori in un blocco switch perché i casi non vengono separati ma fanno parte tutti dello stesso blocco.


switch (x) {
  case 0:
    let foo;
    break;
    
  case 1:
    let foo; // TypeError for redeclaration.
    break;
}

Esempi

Una let expression può essere usata per limitare la visibilità della variabile dichiarata alla sola espressione chiamata.


var a = 5;
let(a = 6) alert(a); // 6
alert(a); // 5

Usando let in un blocco di codice ne limitiamo la visibilità al solo blocco racchiuso. Nel codice di esempio nota come le due assegnazioni nel blocco if diano due risultati diversi.


var a = 5;
var b = 10;

if (a === 5) {
  let a = 4; // The scope is inside the if-block
  var b = 1; // The scope is inside the function

  console.log(a);  // 4
  console.log(b);  // 1
} 

console.log(a); // 5
console.log(b); // 1

Puoi usare let come iteratore in un ciclo for invece di usare una nuova variabile globale.


for (let i = 0; i<10; i++) {
  alert(i); // 1, 2, 3, 4 ... 9
}

alert(i); // i is not defined

Quando lavori con i costruttori puoi usare let per creare in'interfaccia privata senza chiusure.


/*\
|*|
|*|  :: A public and reusable API for constructors ... ::
|*|
\*/

let (
  switchScope = function (oOwner, fConstructor) {
    return oOwner && oOwner.constructor === fConstructor ? oOwner : this;
  }
) {
  function buildIndoors (fConstructor) {
    const oPrivate = new fConstructor(this);
    this.getScope = oPrivate.getScope = switchScope.bind(this, oPrivate);
    return oPrivate;
  }
}

/*\
|*|
|*|  :: Use of the *let* statement in order to create a private interface without closures... ::
|*|
\*/

let (

  /* "Secrets" is the constructor of the private interface */

  Secrets = function Secrets (oPublic /* (the public interface) */) {
    /* setting a private property... */
    this.password = Math.floor(Math.random() * 1e16).toString(36);
    /* you can also store the public interface into a private property... */
    /* this.publicInterface = oPublic; */
    alert("I\'m getting a public property from a private constructor...: somePublicProperty: " + oPublic.somePublicProperty);
  }

) {

  /* "User" is the constructor of the public interface */

  function User (sNick) {
    /* setting a public property... */
    this.somePublicProperty = "Hello World!";
    const oPrivate = this.createScope(Secrets); /* (the private interface) */
    /* setting a public property... */
    this.user = sNick;
    alert("I\'m getting a private property from a public constructor...: password: " + oPrivate.password);
  }

  User.prototype.somePublicMethod = function () {
    const oPrivate = this.getScope(Secrets); /* (the private interface) */
    alert("I\'m getting a public property from a public method...: user: " + this.user);
    alert("I\'m getting a private property from a public method...: password: " + oPrivate.password);
    oPrivate.somePrivateMethod();
  };

  Secrets.prototype.somePrivateMethod = function () {
    const oPublic = this.getScope(); /* (the public interface) */
    alert("I\'m getting a public property from a private method...: user: " + oPublic.user);
    alert("I\'m getting a private property from a private method...: password: " + this.password);
  };

  /* ...creating a mutual access... */

  User.prototype.createScope = buildIndoors;
}

/* out of the *let* statement you have not access to the private interface! */

const johnSmith = new User("John Smith");
johnSmith.somePublicMethod();

Browser compatibility

Feature Chrome Edge Firefox (Gecko) Internet Explorer Opera Safari
Basic support 41.0 12 44 (44) 11 17 10.0
Temporal dead zone ? 12 35 (35) 11 ? ?
Allowed in sloppy mode 49.0 ? 44 (44) ? ? ?
Feature Android Android Webview Firefox Mobile (Gecko) IE Mobile Opera Mobile Safari Mobile Chrome for Android
Basic support ? 41.0 44.0 (44) ? ? 10.0 41.0
Temporal dead zone ? ? 35.0 (35) ? ? ? ?
Allowed in sloppy mode No support 49.0 44 (44) ? ? ? 49.0

 

 

See also

Tag del documento e collaboratori

 Hanno collaborato alla realizzazione di questa pagina: crakdelpol, 1ba1, teoli, EdoPut
 Ultima modifica di: crakdelpol,