Saltar al contenido
Fundamentos del lenguaje

Variables: let, const y por qué ya no var

Lección 2 de 912 min4 ejercicios

Una variable es un nombre que le pones a un valor para usarlo después: puntos, nombre, precioTotal. En JavaScript moderno las declaras con dos palabras: let si el valor va a cambiar y const si no.

Qué mirar en el pizarrón

La columna Variables muestra cada nombre con su tipo de declaración y su valor actual. Pulsa Siguiente y fíjate qué pasa cuando cambia puntos, que es let, y cuando se intenta cambiar VIDAS, que es const.

En el pizarrón

let puntos = 10;puntos = puntos + 5; const VIDAS = 3;console.log(puntos, VIDAS); VIDAS = 2;console.log("fin");

Variables

  1. puntoslet · 10
Consola(vacía)

let puntos = 10 crea una variable llamada puntos y le da el valor 10.

Con el foco aquí también puedes avanzar y retroceder con las flechas del teclado.

Ver todos los pasos en texto
  1. Paso 1: let puntos = 10 crea una variable llamada puntos y le da el valor 10. Variables: puntos let · 10.
  2. Paso 2: El motor calcula primero la parte de la derecha, puntos + 5, que vale 15, y después guarda ese resultado en puntos. Con let se puede reasignar. Variables: puntos let · 15.
  3. Paso 3: const VIDAS = 3 crea una constante: un nombre cuyo valor no se puede reasignar. Variables: puntos let · 15, VIDAS const · 3.
  4. Paso 4: console.log muestra los valores actuales de las dos variables. Variables: puntos let · 15, VIDAS const · 3.
  5. Paso 5: Reasignar una const es un error en ejecución: el motor lanza TypeError y el programa se detiene aquí. VIDAS sigue valiendo 3. Variables: puntos let · 15, VIDAS const · 3.
  6. Paso 6: La línea 8 nunca se ejecuta: el error detuvo el programa. Si VIDAS tenía que cambiar, debió declararse con let. Variables: puntos let · 15, VIDAS const · 3.

Declarar y asignar

Crear una variable se llama declararla. Darle un valor se llama asignar. Casi siempre haces las dos cosas en la misma línea:

let edad = 30;

Se lee de izquierda a derecha: let (la palabra que declara), edad (el nombre), = (asignar) y 30 (el valor). El = no significa “es igual a” como en matemáticas: significa “guarda el valor de la derecha en el nombre de la izquierda”. El motor siempre calcula primero lo de la derecha.

Si declaras con let sin dar un valor, la variable existe pero vale undefined:

let apodo;
console.log(apodo); // undefined
apodo = "Pepe";
console.log(apodo); // Pepe

let: un valor que cambia

Con let puedes reasignar la variable las veces que quieras. Para los cambios más comunes hay atajos:

let puntos = 10;
puntos = puntos + 5;  // 15
puntos += 5;          // lo mismo, abreviado: 20
puntos -= 3;          // 17
puntos *= 2;          // 34
puntos++;             // suma 1: 35
console.log(puntos);

Lo que no puedes hacer es declararla dos veces en el mismo bloque. El motor lo detecta antes de ejecutar:

let color = "rojo";
let color = "azul"; // SyntaxError: Identifier 'color' has already been declared
console.log(color);

Si quieres cambiar el valor, quita el segundo let y asígnale el nuevo valor sin más.

const: un nombre que no se reasigna

const declara una constante: un nombre que, una vez asignado, no se puede reasignar. Por eso tiene que recibir su valor en la misma línea; const total; sola es un SyntaxError.

Como viste en el pizarrón, reasignarla lanza un TypeError. Eso es bueno: si un valor no debería cambiar y por error lo cambias, te enteras enseguida.

Ojo con una confusión muy común: const impide reasignar el nombre, pero no congela el valor. Si el valor es un array o un objeto, puedes modificar su contenido:

const lista = ["pan", "leche"];
lista.push("huevos");      // modifica el mismo array: permitido
console.log(lista);

lista = ["otra", "lista"]; // reasigna el nombre: TypeError

Vas a ver por qué pasa esto, y cómo congelar un objeto de verdad, en la sección de Objetos.

Alcance de bloque

Una variable declarada con let o const existe solo dentro del bloque { } donde la declaraste. A eso se le llama su alcance (scope):

const mensaje = "afuera";

if (true) {
  const secreto = "solo aquí dentro";
  console.log(secreto);  // funciona
  console.log(mensaje);  // también: desde dentro se ve lo de afuera
}

console.log(secreto);    // ReferenceError: secreto is not defined

Desde adentro se ve lo de afuera, pero no al revés. Esto evita que las variables de una parte del programa interfieran con las de otra. Vas a profundizar en el tema Scope y cadena de scopes.

¿Y var?

Antes de 2015, la única forma de declarar variables era var. Todavía funciona, y la vas a ver en código viejo y en tutoriales, pero tiene tres comportamientos que causan errores difíciles de encontrar.

1. Ignora los bloques. Una var declarada dentro de un if o un for se “escapa” del bloque:

if (true) {
  var fuga = "me escapé";
  let dentro = "me quedo";
}
console.log(fuga);           // me escapé
console.log(typeof dentro);  // undefined: no existe aquí afuera

2. Se puede declarar dos veces sin ningún aviso. Si en un archivo largo dos partes usan var total, una pisa a la otra en silencio.

3. Se puede usar antes de su declaración. En lugar de un error, vale undefined, y el fallo pasa desapercibido. Con let el motor te avisa:

console.log(a); // undefined, sin error
var a = 1;

console.log(b); // ReferenceError: Cannot access 'b' before initialization
let b = 2;

Por qué pasa esto tiene nombre, hoisting, y lo vas a ver con un pizarrón en la sección Cómo se ejecuta JS por dentro. Por ahora, la conclusión: no uses var en código nuevo.

Resumen

  • Una variable es un nombre para un valor. = significa “guarda lo de la derecha”.
  • const para lo que no se reasigna (la mayoría) y let para lo que cambia.
  • const impide reasignar el nombre, no modificar un array u objeto.
  • let y const tienen alcance de bloque: solo existen dentro de sus { }.
  • var ignora los bloques, permite declarar dos veces y se puede usar antes de declararla. No la uses en código nuevo.

¡A practicar!

Tu progreso se guarda en este navegador.

Autoevaluación: let, const y var

Elige una respuesta en cada pregunta.

  1. Vas a guardar la fecha de nacimiento de una persona, que no va a cambiar. ¿Con qué la declaras?

  2. ¿Qué imprime este código?
    if (true) { let x = 5; }
    console.log(x);

  3. ¿Funciona esto?
    const lista = [1, 2];
    lista.push(3);

  4. ¿Por qué hoy casi no se usa var?

Ordena la salida: Dos variables con el mismo nombre

Hay dos variables llamadas nivel, una dentro del bloque y otra afuera. Ordena las líneas tal como aparecerían en la consola.

let nivel = 1; {  let nivel = 2;  console.log(nivel);} console.log(nivel);nivel = nivel + 10;console.log(nivel);

Consola, de arriba abajo

  1. 11
  2. 2
  3. 1

Detective: Intentos que no bajan

En este juego, los intentos deberían bajar de 3 a 2, pero el programa se detiene a la mitad. Encuentra la línea donde falla y elige el arreglo.

Consola

Te quedan 3
juego.js:3
intentos = intentos - 1;
         ^

TypeError: Assignment to constant variable.

Paso 1: toca la línea de código que causa el error.

Laboratorio: Moderniza este código

Este código funciona, pero usa var. Cámbialo a let y const según corresponda, sin que cambie lo que imprime.

programa.jsse ejecuta mientras escribes

$ node programa.js

(escribe tu código: se ejecuta solo)

Lo que debe cumplir

  • Imprime Ana 15 100 (pendiente)
  • No queda ningún var (pendiente)
  • puntos, que cambia, usa let (pendiente)
  • nombre y MAX_PUNTOS, que no cambian, usan const (pendiente)

    domina-js · JavaScript en español, gratis y paso a paso.