Objeto literal para manejar balance en JavaScript

Aprende a modelar una cuenta bancaria con objetos literales en JavaScript para controlar el balance con seguridad. Verás cómo pasar de variables sueltas a una estructura con métodos, validaciones y la palabra reservada this, evitando errores como terminar con -900 en el saldo.

¿Por qué fallan las variables sueltas en el manejo de balance?

Cuando el estado vive en variables aisladas y varias funciones pueden modificarlas sin control, aparecen inconsistencias. Aunque la lógica “funciona”, puede permitir retirar más de lo disponible y producir saldos negativos.

• Varias funciones pueden “hacer lo que quieran” sobre el estado.
• No hay validaciones de entrada ni límites de negocio.
• El saldo puede quedar en -900, algo que no debería permitirse.

// Variables sueltas sin validaciones.
let balance = 100;

function deposit(amount) {
  balance += amount;
}

function withdraw(amount) {
  balance -= amount; // Sin validaciones.
}

¿Cómo modelar una cuenta con objetos literales en JavaScript?

Al usar un objeto literal, agrupas en una sola estructura los estados (propiedades) y los comportamientos (métodos). Así proteges el balance y haces cumplir reglas claras antes de modificarlo. Además, puedes incorporar identidad, como un owner ID único que no debería cambiar, y estados que sí pueden variar, como balance o el nombre del titular.

// Objeto literal: estados + comportamientos.
const account = {
  owner: 'Felipe',
  balance: 100,

  deposit(amount) {
    if (amount <= 0) {
      throw new Error('El monto debe de ser mayor a cero');
    }
    this.balance += amount;
    return this.balance;
  },

  withdraw(amount) {
    if (amount <= 0) {
      throw new Error('Monto debe ser mayor a cero');
    }
    if (amount > this.balance) {
      throw new Error('Fondos insuficientes');
    }
    this.balance -= amount;
    return this.balance;
  }
};

// Pruebas básicas.
console.log(account.balance);   // 100.
account.deposit(50);            // 150.
account.withdraw(70);           // 80.
console.log(account.balance);   // 80.

• Estados: owner y balance con pares llave-valor.
• Comportamientos: métodos para depositar y retirar con retorno del nuevo balance.
• Identidad: un posible owner ID único que no cambia.
• Estados mutables: nombre del titular y balance pueden actualizarse.

¿Qué validaciones evitan saldos negativos?

Las reglas integradas a los métodos bloquean operaciones inválidas y protegen el aplicativo:

• Monto menor o igual a cero: error con “El monto debe de ser mayor a cero”.
• Monto a retirar mayor que el balance: error “Fondos insuficientes”.
• Uso de throw new Error(...) para detener la ejecución y notificar el fallo.

¿Cómo funciona this dentro de los métodos?

La palabra reservada this dentro del método apunta al objeto que ejecuta la acción. Así, this.balance hace referencia a account.balance durante la llamada.

• El método recibe el amount y valida la entrada.
• this permite modificar el estado correcto del objeto.
• La asignación += o -= actualiza el balance y retorna el nuevo valor.

// Dentro de deposit o withdraw
this.balance; // Referencia a account.balance durante la ejecución del método.

¿Qué habilidades y keywords refuerzas al practicar?

En un archivo como examples.js en la raíz del proyecto, ejercitas un modelado claro y seguro.

• Pensamiento crítico para detectar saldos imposibles como -900.
• Modelado con objetos literales: estados, comportamientos y reglas.
• Propiedades y métodos con retorno del nuevo balance.
• Validaciones de negocio y manejo de errores con throw new Error.
• Uso correcto de la palabra reservada this para referenciar el objeto actual.
• Estados mutables vs. identidad: owner ID estable; nombre y balance cambiantes.
• Operadores de asignación += y -= para actualizar el estado.
• console.log para verificar resultados paso a paso.

¿Te animas a probar variantes y a compartir tus resultados y retos en los comentarios?