Saltar al contenido
Cómo se ejecuta JS por dentro

Closures

Lección 5 de 712 min4 ejercicios

Una función de JavaScript no solo es código: también recuerda las variables del lugar donde nació. Si la sacas de ahí, se lleva ese recuerdo consigo. A esa combinación de función y memoria se le llama closure, y es una de las ideas más poderosas del lenguaje.

Qué mirar en el pizarrón

Los recuadros punteados son entornos: las variables de una llamada a crearContador. Fíjate en que el entorno #1 sigue vivo aunque crearContador ya terminó, y en que el segundo contador tiene su propio entorno.

En el pizarrón

function crearContador() {  let cuenta = 0;  return function () {    cuenta++;    return cuenta;  };} const contar = crearContador();console.log(contar());console.log(contar()); const otro = crearContador();console.log(otro());

Variables

  1. entorno #1{ cuenta: 0 }
Consola(vacía)

Llamar a crearContador() crea un entorno nuevo con su variable cuenta = 0.

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

Ver todos los pasos en texto
  1. Paso 1: Llamar a crearContador() crea un entorno nuevo con su variable cuenta = 0. Variables: entorno #1 { cuenta: 0 }.
  2. Paso 2: crearContador devuelve una función y termina. Normalmente su entorno desaparecería, pero la función devuelta lo sigue usando, así que el entorno #1 sobrevive. Una función junto con el entorno que recuerda es un closure. Variables: contar → función que recuerda el entorno #1, entorno #1 { cuenta: 0 }.
  3. Paso 3: contar() ejecuta la función interna, que encuentra cuenta en su entorno recordado, la sube a 1 y la devuelve. Variables: contar → función que recuerda el entorno #1, entorno #1 { cuenta: 1 }.
  4. Paso 4: El entorno #1 conserva su valor entre llamadas: cuenta pasa a 2. Variables: contar → función que recuerda el entorno #1, entorno #1 { cuenta: 2 }.
  5. Paso 5: Una nueva llamada a crearContador() crea un entorno nuevo (#2), con su propia cuenta = 0. Los dos contadores no se ven entre sí. Variables: contar → función que recuerda el entorno #1, entorno #1 { cuenta: 2 }, otro → función que recuerda el entorno #2, entorno #2 { cuenta: 0 }.
  6. Paso 6: otro() usa el entorno #2: imprime 1. Cada closure tiene su propia memoria privada: nadie más puede tocar esas variables. Variables: contar → función que recuerda el entorno #1, entorno #1 { cuenta: 2 }, otro → función que recuerda el entorno #2, entorno #2 { cuenta: 1 }.

De dónde salen

Ya sabes dos cosas:

  1. Una función ve las variables del scope donde fue escrita (scope léxico).
  2. Cuando una función termina, su scope normalmente desaparece.

Un closure aparece cuando las dos chocan: una función interna sale de la función que la creó (porque se devuelve, se guarda o se pasa a otra función) y sigue necesitando sus variables. El motor no las borra: la función interna se las lleva.

function crearSaludo() {
  const mensaje = "¡Hola!";
  return function () {
    console.log(mensaje);
  };
}

const saludar = crearSaludo();  // crearSaludo ya terminó…
saludar();                       // …pero saludar todavía recuerda mensaje

Cada llamada, un entorno nuevo

Como viste con los contadores del pizarrón, cada ejecución de la función externa crea variables nuevas, y cada función devuelta recuerda las suyas:

function crearContador() {
  let cuenta = 0;
  return () => ++cuenta;
}

const a = crearContador();
const b = crearContador();

console.log(a(), a(), a());  // 1 2 3
console.log(b());            // 1: b tiene su propia cuenta

Para qué sirven

Datos privados. Las variables del entorno no se pueden tocar desde afuera: solo a través de las funciones que las recuerdan.

function crearCuenta(saldoInicial) {
  let saldo = saldoInicial;
  return {
    depositar(monto) { saldo += monto; },
    consultar() { return saldo; },
  };
}

const cuenta = crearCuenta(100);
cuenta.depositar(50);
console.log(cuenta.consultar());  // 150
console.log(cuenta.saldo);        // undefined: no hay forma de llegar a saldo

Fábricas de funciones. Una función que fabrica otras ya configuradas, como crearMultiplicador(2), que vas a escribir en el laboratorio.

Callbacks. Cada vez que pasas una función que usa variables de afuera (a un setTimeout, un addEventListener, un map…), esa función es un closure: recuerda esas variables para cuando la llamen, más tarde.

function avisarEn(segundos, texto) {
  setTimeout(() => {
    console.log(`(${segundos} s después) ${texto}`);
  }, segundos * 1000);
}

Closures en bucles

Con let, cada vuelta de un for tiene su propia variable, así que cada función creada en el bucle recuerda un valor distinto:

const funciones = [];
for (let i = 0; i < 3; i++) {
  funciones.push(() => i);
}
console.log(funciones[0](), funciones[1](), funciones[2]());  // 0 1 2

Con var habría una sola i compartida por todas las vueltas, y las tres funciones devolverían 3. Era un error clásico antes de 2015, y otra razón para no usar var.

Resumen

  • Un closure es una función junto con las variables del entorno donde nació.
  • La función puede seguir usando esas variables aunque la función que las creó ya haya terminado.
  • Cada llamada a la función externa crea un entorno nuevo e independiente.
  • Sirven para datos privados, fábricas de funciones y callbacks que recuerdan estado.
  • Con let, cada vuelta de un bucle tiene su propia variable para los closures.

¡A practicar!

Tu progreso se guarda en este navegador.

Autoevaluación: Funciones con memoria

Elige una respuesta en cada pregunta.

  1. ¿Qué es un closure?

  2. Llamas dos veces a crearContador(). ¿Los dos contadores comparten la cuenta?

  3. const fs = []; for (let i = 0; i < 3; i++) fs.push(() => i); ¿Qué da fs[0]()?

  4. ¿Para qué sirven los closures en la práctica?

Ordena la salida: Una fábrica de saludos

Dos funciones fabricadas por la misma fábrica. Ordena lo que aparecería en la consola.

function crearSaludo(saludo) {  return function (nombre) {    return `${saludo}, ${nombre}`;  };} const hola = crearSaludo("Hola");const buenas = crearSaludo("Buenas"); console.log(hola("Ana"));console.log(buenas("Luis"));console.log(hola("Eva"));

Consola, de arriba abajo

  1. Hola, Eva
  2. Hola, Ana
  3. Buenas, Luis

Detective: Un contador que no es función

Este contador debería funcionar como el del pizarrón, pero lanza un error. Encuentra la línea donde falla y elige el arreglo.

Consola

contador.js:10
console.log(contar());
            ^

TypeError: contar is not a function

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

Laboratorio: Una fábrica de multiplicadores

Escribe la función crearMultiplicador: recibe un factor y devuelve una función que multiplica por ese factor.

programa.jsse ejecuta mientras escribes

$ node programa.js

(escribe tu código: se ejecuta solo)

Lo que debe cumplir

  • Imprime 10 y después 15 (pendiente)
  • crearMultiplicador devuelve una función (pendiente)
  • Funciona con cualquier factor: crearMultiplicador(4)(3) da 12 (pendiente)

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