Objeto literal para manejar balance en JavaScript

Contenido del curso

Clases Grabadas

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0010:29

Objeto literal para manejar balance en JavaScript

Curso de JavaScript Orientado a Objetos

Clase 4 de 15

Clase 4 / 15

Recursos

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?

// Ejercicio 8 — Reto final: cuenta con owner ID inmutable

// Agrega un ownerId (ej. crypto.randomUUID() o un string fijo) que represente la identidad de la cuenta. Escribe un método changeOwnerName(newName) que permita cambiar el nombre del titular, pero asegúrate (con un comentario o validación) de que ownerId nunca se reasigna después de creado el objeto.
function accountSexto() {

    const ownerId = crypto.randomUUID();

    return {
        owner: 'Juan',
        balance: 200,
        history: [],
        overdraftLimit: -100,
        deposit(amount) {
            if (amount <= 0) throw new Error('El monto debe ser mayor a 0');

            this.balance += amount;
            this.history.push({
                type: 'deposit',
                amount: amount,
                balanceAfter: this.balance
            })
            return this.balance;
        },

        withdraw(amount) {
            if (amount <= 0) throw new Error('El monto debe ser mayor a 0');

            const operation = this.balance - amount;

            if (operation < this.overdraftLimit) throw new Error(`Valor máximo que puede sobregirar es ${this.overdraftLimit}`);




            this.balance -= amount;
            this.history.push({
                type: 'withdraw',
                amount: amount,
                balanceAfter: this.balance
            })
            return this.balance;
        },

        printHistory() {
            // return [...this.history]
            this.history.forEach((history) => {
                console.log(`
                Tipo de movimiento: ${history.type}
                Cantidad: ${history.amount}
                Balance despues del movimiento: ${history.balanceAfter}
            `)
            })
        },

        getBalance() {
            return this.balance;
        },

        changeOwnerName(newName) {

            if (typeof newName !== 'string') throw new Error(`El cambio de nombre debe ser de tipo string no de tipo ${typeof (newName)}`)

            this.owner = newName;
        },
        
        getOwnerId() {
            return ownerId;
        }
    }
}

// const accountSextoPrueba = accountSexto();
// console.log(accountSextoPrueba);
// console.log(accountSextoPrueba.getOwnerId());
// accountSextoPrueba.changeOwnerName('Carlos');
// console.log(accountSextoPrueba.getOwnerId());
// console.log(accountSextoPrueba);

const accountSextoPrueba = accountSexto();
accountSextoPrueba.changeOwnerName('Carlos');

console.log(accountSextoPrueba.owner);
console.log(accountSextoPrueba.getOwnerId());

// Ejercicio 8 — Reto final: cuenta con owner ID inmutable

// Agrega un ownerId (ej. crypto.randomUUID() o un string fijo) que represente la identidad de la cuenta. Escribe un método changeOwnerName(newName) que permita cambiar el nombre del titular, pero asegúrate (con un comentario o validación) de que ownerId nunca se reasigna después de creado el objeto.
function accountSexto() {

    const ownerId = crypto.randomUUID();

    return {
        owner: 'Juan',
        balance: 200,
        history: [],
        overdraftLimit: -100,
        deposit(amount) {
            if (amount <= 0) throw new Error('El monto debe ser mayor a 0');

            this.balance += amount;
            this.history.push({
                type: 'deposit',
                amount: amount,
                balanceAfter: this.balance
            })
            return this.balance;
        },

        withdraw(amount) {
            if (amount <= 0) throw new Error('El monto debe ser mayor a 0');

            const operation = this.balance - amount;

            if (operation < this.overdraftLimit) throw new Error(`Valor máximo que puede sobregirar es ${this.overdraftLimit}`);




            this.balance -= amount;
            this.history.push({
                type: 'withdraw',
                amount: amount,
                balanceAfter: this.balance
            })
            return this.balance;
        },

        printHistory() {
            // return [...this.history]
            this.history.forEach((history) => {
                console.log(`
                Tipo de movimiento: ${history.type}
                Cantidad: ${history.amount}
                Balance despues del movimiento: ${history.balanceAfter}
            `)
            })
        },

        getBalance() {
            return this.balance;
        },

        changeOwnerName(newName) {

            if (typeof newName !== 'string') throw new Error(`El cambio de nombre debe ser de tipo string no de tipo ${typeof (newName)}`)

            this.owner = newName;
        },
        
        getOwnerId() {
            return ownerId;
        }
    }
}

// const accountSextoPrueba = accountSexto();
// console.log(accountSextoPrueba);
// console.log(accountSextoPrueba.getOwnerId());
// accountSextoPrueba.changeOwnerName('Carlos');
// console.log(accountSextoPrueba.getOwnerId());
// console.log(accountSextoPrueba);

const accountSextoPrueba = accountSexto();
accountSextoPrueba.changeOwnerName('Carlos');

console.log(accountSextoPrueba.owner);
console.log(accountSextoPrueba.getOwnerId());

Clases Grabadas

POO en JavaScript: cómo pensar antes de programar

Configuración de proyecto JavaScript con Git y npm

Función constructora y prototipo en JavaScript

Objeto literal para manejar balance en JavaScript

Cómo funcionan los prototipos en JavaScript

Clases en JavaScript: constructor y métodos static

Campos privados y setters con validación en JavaScript

Composición en POO: delegar logs a LogTracker

Polimorfismo en JavaScript con duck typing

Herencia en TypeScript: extends y super

Abstracción en POO: ocultar complejidad

Polimorfismo aplicado a calculadoras de rachas

Factory methods para hábitos en JavaScript

Errores de dominio con códigos y validación robusta

POO en JavaScript: cuándo usar objetos y funciones

Objeto literal para manejar balance en JavaScript

Progreso del curso

Clases Grabadas

Recursos

Recursos