La instrucciónlet declara una variable de alcance local con ámbito de bloque(blockscope), la cual, opcionalmente, puede ser inicializada con algún valor.

Sintaxis

let var1 [= valor1] [, var2 [= valor2]] [, ..., varN [= valorN]];

Parámetros

var1,var2, …,varN

Los nombres de la variable o las variables a declarar. Cada una de ellas debe ser un identificador legal de JavaScript

value1,value2, …,valueN

Por cada una de las variables declaradas puedes, opcionalmente, especificar su valor inicial como una expresión legal JavaScript.

Descripción

let te permite declarar variables limitando su alcance (scope) al bloque, declaración, o expresión donde se está usando.a diferencia de la palabra clavevar la cual define una variable global o local en una función sin importar el ámbito del bloque. La otra diferencia entrevar ylet es que este último se inicializa a un valor sólo cuando un analizador lo evalúa (ver abajo).

Al igual queconst,let no crea propiedades del objeto se declara globalmente (en el alcance más alto).

Alcance (scope) a nivel de bloque conlet

Usar la palabra reservadalet para definir variables dentro de un bloque.

if (x > y) {  let gamma = 12.7 + y;  i = gamma * x;}

Es posible usar definicioneslet para asociar código en extensiones con un pseudo-espacio-de-nombre (pseudo-namespace). (VerMejores prácticas de seguridad en extensiones.)

let Cc = Components.classes,  Ci = Components.interfaces;

let puede ser útil para escribir código más limpio cuando usamos funciones internas.

var list = document.getElementById("list");for (var i = 1; i <= 5; i++) {  var item = document.createElement("LI");  item.appendChild(document.createTextNode("Item " + i));  let j = i;  item.onclick = function (ev) {    console.log("Item " + j + " is clicked.");  };  list.appendChild(item);}

El ejemplo anterior trabaja como se espera porque las cinco instancias de la función (anónima) interna hacen referencia a cinco diferentes instancias de la variablej. Nótese que esto no funcionaría como se espera si reemplazamoslet convar o si removemos la variablej y simplemente usamos la variablei dentro de la función interna.

Reglas de alcance

Variables declaradas porlet tienen por alcance el bloque en el que se han definido, así mismo, como en cualquier bloque interno. De esta manera,let trabaja muy parecido avar. La más notable diferencia es que el alcance de una variablevar es la función contenedora:

function varTest() {  var x = 31;  if (true) {    var x = 71; // ¡misma variable!    console.log(x); // 71  }  console.log(x); // 71}function letTest() {  let x = 31;  if (true) {    let x = 71; // variable diferente    console.log(x); // 71  }  console.log(x); // 31}// llamamos a las funcionesvarTest();letTest();

En el nivel superior de un programa y funciones,let , a diferencia devar,no crea una propiedad en el objeto global, por ejemplo:

var x = "global";let y = "global";console.log(this.x); // "global"console.log(this.y); // undefined

La salida de este código desplegaría "global" una vez.

Zona muerta temporal y errores conlet

Laredeclaración de la misma variable bajo un mismoámbito léxico terminaría en un error de tipoSyntaxError. Esto también esextensible si usamosvar dentro del ámbito léxico. Esto nos salvaguarda de redeclarar una variable accidentalmente y que no era posible solo convar.

if (x) {  let foo;  let foo; // Terminamos con un SyntaxError.}if (x) {  let foo;  var foo; // Terminamos con un SyntaxError.}

En ECMAScript 2015,letno eleva la variable a la parte superior del bloque. Si se hace una referencia a la variable declarada conlet (let foo) antes de su declaración, terminaríamos con un error de tipoReferenceError (al contrario de la variable declarada convar, que tendrá el valorundefined), esto porque la variables vive en una "zona muerta temporal" desde el inicio del bloque hasta que la declaración ha sido procesada.

function do_something() {  console.log(bar); // undefined  console.log(foo); // ReferenceError: foo no está definido  var bar = 1;  let foo = 2;}

Es posible encontrar errores en bloques de controlswitch debido a que solamente existe un block subyacente.

switch (x) {  case 0:    let foo;    break;  case 1:    let foo; // Terminamos con un error de tipo SyntaxError.    // esto debido a la redeclaracion    break;}

Otro ejemplo de zona muerta temporal combinada con ámbito léxico

Debido alámbito léxico, el identificadornum dentro de la expresión (num + 55) se evalúa comonum del bloqueif, y no como la variablenum con el valor 33 que esta por encima

En esa misma línea, elnum del bloqueif ya se ha creado en el ámbito léxico, pero aún no ha alcanzado (yterminado) su inicialización (que es parte de la propia declaración): todavía está en la zona muerta temporal.

function prueba() {  var num = 33;  if (true) {    let num = num + 55; //ReferenceError: no se puede acceder a la declaración léxica `num'antes de la inicialización  }}prueba();

Ejemplos

let vsvar

Cuando usamoslet dentro de un bloque, podemos limitar el alcance de la variable a dicho bloque. Notemos la diferencia convar, cuyo alcance reside dentro de la función donde ha sido declarada la variable.

var a = 5;var b = 10;if (a === 5) {  let a = 4; // El alcance es dentro del bloque if  var b = 1; // El alcance es global  console.log(a); // 4  console.log(b); // 1}console.log(a); // 5console.log(b); // 1

let en bucles

Es posible usar la palabra reservadalet para enlazar variables con alcance local dentro del alcance de un bucle en lugar de usar una variable global (definida usandovar) para dicho propósito.

for (let i = 0; i < 10; i++) {  console.log(i); // 0, 1, 2, 3, 4 ... 9}console.log(i); // ReferenceError: i is not defined

Extensioneslet no-estandar

Bloqueslet

Unbloquelet provee una manera de asociar valores con variables dentro del alcance de un bloque sin afectar el valor de variables con nombre similar fuera del bloque.

Sintaxis

let (var1 [= value1] [, var2 [= value2]] [, ..., varN [= valueN]]) {declaración};

Descripción

El bloquelet provee alcance local para las variables. Funciona enlazando cero o más variables en el alcance léxico de un solo bloque de código; de otra manera, es exactamente lo mismo que una declaración de bloque. Hay que notar particularmente que el alcance de una variable declarada dentro de un bloquelet usando var es equivalente a declarar esa variable fuera del bloquelet; dicha variable aún tiene alcance dentro de la función. Al usar la sintaxis de bloquelet, los paréntesis siguientes alet son requeridos. Una falla al incluir dichos paréntesis resultará en un error de sintaxis.

Ejemplo

var x = 5;var y = 0;let (x = x+10, y = 12) {  console.log(x+y); // 27}console.log(x + y); // 5

Las reglas para el bloque de código son las mismas que para cualquier otro bloque de código en JavaScript. Es posible tener sus propias variables locales usando declaracioneslet en dicho bloque.

Reglas de alcance

El alcance de las variables definidas usandolet es el mismo bloquelet, así como cualquier bloque interno contenido dentro de el bloque, a menos que esos bloques internos definan variables con el mismo nombre.

expresioneslet

Unaexpresionlet permite establecer variables con alcance dentro de una expresión.

Sintaxis

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

Ejemplo

Podemos usarlet para establecer variables que tienen como alcance solo una expresión:

var a = 5;let(a = 6) console.log(a); // 6console.log(a); // 5

Reglas de alcance

Dada la expresiónlet siguiente:

let (decls) expr

Existe un bloque implícito creado alrededor de expr.

Especificaciones

Compatibilidad en navegadores

Ver también

• var
• const