De dónde salen
Ya sabes dos cosas:
- Una función ve las variables del scope donde fue escrita (scope léxico).
- 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
Resuelto
Elige una respuesta en cada pregunta.
¿Qué es un closure?
Llamas dos veces a
crearContador(). ¿Los dos contadores comparten la cuenta?const fs = []; for (let i = 0; i < 3; i++) fs.push(() => i);¿Qué dafs[0]()?¿Para qué sirven los closures en la práctica?
Ordena la salida: Una fábrica de saludos
Resuelto
Dos funciones fabricadas por la misma fábrica. Ordena lo que aparecería en la consola.
1function crearSaludo(saludo) {2 return function (nombre) {3 return `${saludo}, ${nombre}`;4 };5}6 7const hola = crearSaludo("Hola");8const buenas = crearSaludo("Buenas");9 10console.log(hola("Ana"));11console.log(buenas("Luis"));12console.log(hola("Eva"));Consola, de arriba abajo
- Hola, Eva
- Hola, Ana
- Buenas, Luis
Cada llamada a crearSaludo crea un entorno con su propio saludo. hola recuerda "Hola" y buenas recuerda "Buenas", aunque crearSaludo ya terminó hace rato.
Detective: Un contador que no es función
Resuelto
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 functionPaso 1: toca la línea de código que causa el error.
Paso 2: ¿cómo lo arreglas?
Laboratorio: Una fábrica de multiplicadores
Resuelto
Escribe la función crearMultiplicador: recibe un factor y devuelve una función que multiplica por ese factor.
$ node programa.js
Lo que debe cumplir
- Imprime
10y después15(pendiente) crearMultiplicadordevuelve una función (pendiente)- Funciona con cualquier factor:
crearMultiplicador(4)(3)da12(pendiente)
Una solución
1function crearMultiplicador(factor) {2 return function (n) {3 return n * factor;4 };5}6 7const doble = crearMultiplicador(2);8const triple = crearMultiplicador(3);9 10console.log(doble(5));11console.log(triple(5));Cada llamada a crearMultiplicador fabrica una función nueva que recuerda su propio factor. Es el patrón fábrica: en lugar de escribir doble, triple y cuadruple a mano, generas las que necesites.