ES2015 (ES6) añadió dos palabras clave importantes de JavaScript:letyconst。

Las variables declaradas con let solo son válidas dentro del bloque de código donde se encuentra la sentencia let.

const declara una constante de solo lectura; una vez declarada, el valor de la constante no puede cambiar.

Sentencia let

Uso básico:

{ let a = 0; a // 0 } a //Se produce un error: ReferenceError: a is not defined

Válido dentro del bloque de código

let es válido dentro del bloque de código, var es válido en el ámbito global:

{ let a = 0; var b = 1; } a // ReferenceError: a is not defined b // 1

No se puede declarar repetidamente

let solo puede declararse una vez; var puede declararse varias veces:

let a = 1; let a = 2; var b = 3; var b = 4; a // Identifier 'a' has already been declared b // 4

El contador del bucle for es muy adecuado para usar let

for (var i = 0; i < 10; i++) { setTimeout(function(){ console.log(i); }) } //Imprime diez 10 for (let j = 0; j < 10; j++) { setTimeout(function(){ console.log(j); }) } //Imprime 0123456789

La variable i se declara con var y es válida en el ámbito global, por lo que solo hay una variable i en el ámbito global. En cada iteración, la i dentro del temporizador setTimeout se refiere a la variable global i, y los diez setTimeout del bucle se ejecutan después de que el bucle haya terminado, por lo que en ese momento todas las i son 10.

La variable j se declara con let; la j actual solo es válida en la iteración actual del bucle. De hecho, cada iteración tiene una nueva variable j, por lo que la j dentro del temporizador setTimeout es una variable distinta, es decir, finalmente se imprime 12345. (Si la variable j se vuelve a declarar en cada iteración, ¿cómo se sabe el valor de la iteración anterior? Esto se debe a que el motor de JavaScript recuerda internamente el valor de la iteración anterior).

No existe la elevación de variables (hoisting)

let no tiene elevación de variables, var sí tiene elevación de variables:

console.log(a); //ReferenceError: a is not defined let a = "apple"; console.log(b); //undefined var b = "banana";

La variable b se declara con var y tiene elevación de variables, por lo que cuando el script comienza a ejecutarse, b ya existe, pero aún no tiene un valor asignado, por lo que se imprime undefined.

La variable a se declara con let y no tiene elevación de variables. Antes de declarar la variable a, a no existe, por lo que se produce un error.

Sentencia const

const declara una variable de solo lectura; una vez declarada, no se permite que cambie. Esto significa que, una vez declarada, debe ser inicializada; de lo contrario, se produce un error.

Uso básico:

const PI = "3.1415926";
PI  // 3.1415926

const MY_AGE;  // SyntaxError: Missing initializer in const declaration

Zona muerta temporal:

var PI = "a";
if(true){
  console.log(PI);  // Cannot access 'PI' before initialization
  const PI = "3.1415926";
}

ES6 estipula claramente que si dentro de un bloque de código hay let o const, el bloque formará un ámbito cerrado para las variables declaradas por estas sentencias desde el inicio del bloque. Dentro del bloque, usarla antes de declarar la variable PI producirá un error.

Puntos clave

¿Cómo hace const para que la variable no pueda cambiar después de ser declarada e inicializada? En realidad, const no garantiza que el valor de la variable no cambie, sino que garantiza que los datos almacenados en la dirección de memoria a la que apunta la variable no puedan modificarse. En este punto, quizás ya hayas pensado que los tipos simples y los tipos compuestos almacenan los valores de manera diferente. Así es: para los tipos simples (number, string, boolean), el valor se guarda en la dirección de memoria a la que apunta la variable, por lo que las variables de tipo simple declaradas con const equivalen a constantes. En cambio, para los tipos compuestos (object, array, function), la dirección de memoria a la que apunta la variable guarda en realidad un puntero a los datos reales, por lo que const solo puede garantizar que el puntero sea fijo, pero no puede controlar si la estructura de datos a la que apunta el puntero cambia o no. Por lo tanto, hay que tener cuidado al declarar objetos de tipos compuestos con const.

Artículos de referencia