Closures en JavaScript: estado privado en cuentas

Aprende a dominar los closures en JavaScript con un ejemplo claro y práctico: una cuenta bancaria con estado privado. Aquí verás cómo una función recuerda su scope incluso después de ejecutarse, permitiendo encapsular datos, exponer métodos seguros y mantener consistencia del estado.

¿Qué es un closure y por qué importa en JavaScript?

Un closure es “una función que recuerda el scope en el cual fue creada, incluso después de que esta ha sido ejecutada”. En este caso, la variable saldo se define como privada y solo es accesible por los métodos retornados. Así se evita exponer directamente el estado y se controlan las operaciones disponibles.

¿Cómo recuerda el scope y mantiene estado privado?

• Se define let saldo = saldoInicial dentro de la función creadora.
• Los métodos retornados acceden a saldo gracias al closure.
• El estado persiste entre invocaciones: cada depósito o retiro actualiza saldo sin exponerlo públicamente.

¿Qué operaciones se habilitan con estado privado?

• depositar(cantidad): suma al saldo y devuelve un mensaje con el nuevo total.
• retirar(cantidad): valida fondos, evita “dinero infinito” y actualiza el saldo.
• consultarSaldo(): retorna el saldo actual en formato legible.

¿Cómo crear una cuenta bancaria con closure en JavaScript?

A continuación, la función que crea la cuenta, encapsula saldo y retorna métodos para operar con la cuenta. Observa cómo cada método accede a saldo gracias al closure.

function crearCuentaBancaria(saldoInicial) {
  let saldo = saldoInicial; // estado privado

  return {
    depositar(cantidad) {
      saldo += cantidad;
      return `Depositado $${cantidad}. Saldo actual: $${saldo}.`;
    },
    retirar(cantidad) {
      if (cantidad > saldo) {
        return 'Fondos insuficientes.';
      }
      saldo -= cantidad;
      return `Retirado $${cantidad}. Saldo actual: $${saldo}.`;
    },
    consultarSaldo() {
      return `Saldo: $${saldo}.`;
    }
  };
}

¿Qué validaciones y mensajes devuelve cada método?

• depositar: retorna “Depositado $cantidad. Saldo actual: $nuevoSaldo.”.
• retirar: si no hay fondos, retorna “Fondos insuficientes.”.
• retirar: en caso válido, retorna “Retirado $cantidad. Saldo actual: $nuevoSaldo.”.
• consultarSaldo: retorna “Saldo: $saldo.”.

¿Cómo instanciar múltiples cuentas y probar operaciones?

Cada instancia recuerda su propio scope, por lo que mantiene su saldo independiente.

// Instancia 1
const miCuenta = crearCuentaBancaria(1000);
console.log(miCuenta.consultarSaldo());    // Saldo: $1000.
console.log(miCuenta.depositar(500));      // Depositado $500. Saldo actual: $1500.
console.log(miCuenta.retirar(200));        // Retirado $200. Saldo actual: $1300.

// Instancia 2
const miCuenta2 = crearCuentaBancaria(200);
console.log(miCuenta2.consultarSaldo());   // Saldo: $200.

• Cada cuenta es independiente: no comparten saldo.
• La variable saldo queda encapsulada y privada dentro de cada instancia.

¿Qué buenas prácticas refuerza este ejercicio?

Además de entender el closure, el ejemplo resalta detalles que evitan errores y mejoran la lectura del código.

¿Cómo escribir nombres y retornos para evitar fallos?

• Asegura retornos en métodos cuando se espera salida visible.
• Cuida nombres de variables y métodos: evita errores tipográficos en saldo, cantidad, consultarSaldo.
• Usa una nomenclatura clara con mayúsculas internas para separar palabras: crearCuentaBancaria, saldoInicial, miCuenta.
• Encapsula el estado con closure para proteger datos sensibles como el saldo.
• Crea múltiples instancias cuando necesites alcances independientes: cada una recuerda su contexto.

¿Agregarías otra operación como transferencia o historial? Cuéntalo en los comentarios y comparte tu solución con la comunidad.