JavaScript Academy · Lección

Variables privadas con clausuras

Oculte el estado dentro del ámbito de una función.

Variables privadas con clausuras es una lección gratuita de JavaScript Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de JavaScript Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de JavaScript Academy incluye 4 lecciones en total.

Privacidad mediante clausuras

Durante mucho tiempo, JavaScript no tuvo una forma integrada de hacer privados los campos de un objeto. Las clausuras proporcionan una: las variables dentro de una función son invisibles desde fuera, pero las funciones definidas en su interior pueden acceder a ellas.

function secretBox() {
  let secret = "hidden";
  return {
    reveal: () => secret
  };
}
const box = secretBox();
console.log(box.reveal()); // "hidden"
console.log(box.secret);   // undefined

Un contador con estado privado

El ejemplo clásico: un contador cuyo valor no se puede manipular directamente. Solo los métodos devueltos pueden modificarlo.

function makeCounter() {
  let count = 0;
  return {
    increment: () => ++count,
    value: () => count
  };
}
const c = makeCounter();
c.increment();
c.increment();
console.log(c.value()); // 2

El estado es inaccesible

No hay forma de acceder a count desde fuera. Los intentos de leerlo devuelven undefined; debe hacerlo mediante los métodos.

function makeCounter() {
  let count = 0;
  return { inc: () => ++count, get: () => count };
}
const c = makeCounter();
c.count = 100;        // creates an unrelated property
console.log(c.get()); // 0 - real count untouched

Aplicación de reglas

Como el acceso se realiza mediante métodos, puede imponer invariantes, como no permitir nunca que un saldo sea negativo.

function account(start) {
  let balance = start;
  return {
    withdraw: (n) => {
      if (n > balance) return "insufficient";
      balance -= n;
      return balance;
    },
    balance: () => balance
  };
}
const a = account(100);
console.log(a.withdraw(150)); // "insufficient"
console.log(a.withdraw(40));  // 60

Varios campos privados

Una clausura puede proteger varias variables a la vez. Todas están ocultas y solo se comparten entre los métodos devueltos.

function user(name) {
  let logins = 0;
  let lastSeen = null;
  return {
    login: () => { logins++; lastSeen = "now"; },
    stats: () => ({ name, logins, lastSeen })
  };
}
const u = user("Ada");
u.login();
console.log(u.stats()); // { name: "Ada", logins: 1, lastSeen: "now" }

Funciones auxiliares privadas

No solo los datos: también puede ocultar funciones internas. Solo los métodos que exponga serán públicos.

function temperature() {
  let celsius = 0;
  const toF = (c) => c * 9 / 5 + 32; // private
  return {
    set: (c) => { celsius = c; },
    fahrenheit: () => toF(celsius)
  };
}
const t = temperature();
t.set(100);
console.log(t.fahrenheit()); // 212

Instancias independientes

Cada llamada a la factoría crea un estado privado independiente, por lo que las instancias nunca interfieren entre sí.

function makeCounter() {
  let n = 0;
  return { inc: () => ++n };
}
const a = makeCounter();
const b = makeCounter();
console.log(a.inc(), a.inc()); // 1 2
console.log(b.inc());          // 1

Exposición de solo lectura

Exponga un getter sin setter para hacer que un valor sea de solo lectura desde fuera, aunque siga siendo modificable internamente.

function timer() {
  let ticks = 0;
  setupInternally();
  function setupInternally() { ticks = 3; }
  return { ticks: () => ticks };
}
const t = timer();
console.log(t.ticks()); // 3 - no way to set it outside

Comparación: campos de clase

JavaScript moderno también admite campos de clase #private. Las clausuras siguen siendo útiles para las funciones factoría y cuando desea privacidad sin clases.

class Counter {
  #count = 0;
  inc() { return ++this.#count; }
}
const c = new Counter();
console.log(c.inc()); // 1

Por qué funciona

Los métodos devueltos son clausuras sobre las variables externas. La función externa ha devuelto el control, pero su ámbito sigue existiendo porque esas clausuras aún hacen referencia a él.

Una caché de memoización

El estado privado es ideal para las cachés. El objeto de la caché permanece oculto y conserva su contenido entre llamadas.

function memoSquare() {
  const cache = {};
  return (n) => {
    if (cache[n] === undefined) cache[n] = n * n;
    return cache[n];
  };
}
const sq = memoSquare();
console.log(sq(4)); // 16
console.log(sq(4)); // 16 (cached)

Comprobación rápida

Variables privadas con clausuras.

Resumen

Las clausuras crean privacidad: las variables dentro de una factoría son inaccesibles desde fuera, pero se comparten entre los métodos devueltos. Esto permite crear contadores a prueba de manipulaciones, saldos con invariantes, funciones auxiliares ocultas y cachés. Cada llamada a la factoría produce un estado independiente. Los campos de clase modernos #private son una alternativa, pero las clausuras destacan en el código basado en factorías.

Preguntas frecuentes

¿La lección «Variables privadas con clausuras» es gratis?

Sí — el texto completo de «Variables privadas con clausuras» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de JavaScript Academy, actualiza a CoddyKit PRO. El curso de JavaScript Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Variables privadas con clausuras»?

Oculte el estado dentro del ámbito de una función. Practicas JavaScript Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar JavaScript Academy?

No se requiere experiencia previa. JavaScript Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Variables privadas con clausuras»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de JavaScript Academy?

Sí. Cada lección de JavaScript Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a JavaScript Academy