¿Qué es un Closure?

Un closure (o clausura) es una función que “recuerda” las variables del contexto en el que fue definida, aunque ese contexto ya no esté activo. En JavaScript, cada vez que se crea una función dentro de otra, la función interior forma un closure con las variables de la exterior.

¿Para qué se utiliza?

Los closures se usan para:

• Crear variables privadas que no son accesibles desde fuera de una función.
• Implementar el patrón módulo para encapsular lógica.
• Mantener estado entre llamadas a una función sin usar variables globales.
• Construir funciones de fábrica que generan funciones personalizadas.
• Gestionar callbacks y eventos que necesitan acceso a datos del contexto original.

¿Cómo funciona?

Imagina un closure como una mochila invisible que lleva cada función. Cuando se crea una función, mete en esa mochila todas las variables del entorno que la rodea. Aunque el entorno original desaparezca, la mochila sigue ahí, accesible solo para esa función.

Ejemplo: Contador con estado privado

function crearContador() {
  let cuenta = 0; // Variable "privada" — no accesible desde fuera

  return {
    incrementar() {
      cuenta++;
    },
    decrementar() {
      cuenta--;
    },
    valor() {
      return cuenta; // El closure recuerda 'cuenta'
    },
  };
}

const contador = crearContador();
contador.incrementar();
contador.incrementar();
contador.incrementar();
contador.decrementar();

console.log(contador.valor()); // 2
console.log(cuenta); // ReferenceError: 'cuenta' no existe fuera del closure

Ejemplo: Fábrica de funciones

// Genera funciones personalizadas usando closures
function multiplicadorDe(factor) {
  return function (numero) {
    return numero * factor; // 'factor' vive en el closure
  };
}

const doble = multiplicadorDe(2);
const triple = multiplicadorDe(3);

console.log(doble(5));  // 10
console.log(triple(5)); // 15
console.log(doble(10)); // 20

---

Los closures son uno de los conceptos más potentes — y a veces más confusos — de JavaScript. Entenderlos bien es clave para escribir código limpio y para comprender patrones como módulos, decoradores o la programación funcional.

---

---