mozilla

let

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.
}
Warning: ECMAScript 6 drafts (as of April, 2012) make this behavior illegal. That means that future versions of JavaScript will likely be consistent and raise a TypeError if you do this, so you should avoid this practice!

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();

See also

Etichette del documento e nomi di chi ha collaborato alla sua stesura

Contributors to this page: teoli, EdoPut
Ultima modifica di: teoli,
Nascondi barra laterale