Taller 11 Parte 2: Ejercicios de Funciones en JavaScript

                            
// Función anónima asignada a una variable
const calcularArea = function(ancho, alto) {
    return ancho * alto;
};

// Prueba de la función
const area = calcularArea(5, 8);
console.log(`El área del rectángulo es: ${area}`); // 40

// Ejemplo adicional
console.log(calcularArea(10, 3)); // 30
                            
                        

                            
// Array de números
const numeros = [1, 2, 3, 4, 5];

// Usar map con función anónima
const duplicados = numeros.map(function(numero) {
    return numero * 2;
});

console.log("Números originales:", numeros);
console.log("Números duplicados:", duplicados);
                            
                        

                            
// Arrow function - sintaxis corta
const cuadrado = num => num * num;

// Arrow function - sintaxis completa
const cuadradoCompleto = (num) => {
    return num * num;
};

// Pruebas
console.log(cuadrado(4)); // 16
console.log(cuadrado(7)); // 49
console.log(cuadradoCompleto(5)); // 25
                            
                        

                            
// Array de números del 1 al 10
const numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

// Método por pasos
const pares = numeros.filter(num => num % 2 === 0);
const cubos = pares.map(num => num ** 3);

console.log("Números originales:", numeros);
console.log("Números pares:", pares);
console.log("Cubos de pares:", cubos);

// Método encadenado
const resultado = numeros
    .filter(num => num % 2 === 0)
    .map(num => num ** 3);

console.log("Resultado encadenado:", resultado);
                            
                        

                            
// Función principal que usa callback
function procesarNumero(numero, callback) {
    return callback(numero);
}

// Callbacks
const duplicar = (num) => num * 2;
const triplicar = (num) => num * 3;
const cuadrado = (num) => num * num;

// Pruebas
console.log(procesarNumero(5, duplicar)); // 10
console.log(procesarNumero(5, triplicar)); // 15
console.log(procesarNumero(5, cuadrado)); // 25

// Uso con función anónima
console.log(procesarNumero(8, function(n) { return n + 10; })); // 18
                            
                        

                            
// Implementación personalizada de forEach
function miForEach(array, callback) {
    for (let i = 0; i < array.length; i++) {
        callback(array[i], i, array);
    }
}

// Array de prueba
const letras = ['a', 'b', 'c'];

// Callback que muestra elemento e índice
miForEach(letras, (elemento, indice) => {
    console.log(`Elemento: ${elemento}, Índice: ${indice}`);
});

// Callback que muestra todo
miForEach(letras, (elemento, indice, array) => {
    console.log(`${elemento} en posición ${indice} de [${array}]`);
});
                            
                        

                            
// Función de orden superior que retorna una función
function crearMultiplicador(factor) {
    return function(numero) {
        return numero * factor;
    };
}

// Crear multiplicadores específicos
const multiplicarPor2 = crearMultiplicador(2);
const multiplicarPor3 = crearMultiplicador(3);
const multiplicarPor10 = crearMultiplicador(10);

// Pruebas
console.log(multiplicarPor2(5)); // 10
console.log(multiplicarPor3(4)); // 12
console.log(multiplicarPor10(7)); // 70

// Versión con arrow function
const crearMultiplicadorArrow = factor => numero => numero * factor;
const multiplicarPor5 = crearMultiplicadorArrow(5);
console.log(multiplicarPor5(6)); // 30
                            
                        

                            
// Decorador que añade logging a cualquier función
function conLog(func) {
    return function(...args) {
        console.log(`Ejecutando función con argumentos: [${args}]`);
        const resultado = func(...args);
        console.log(`Resultado: ${resultado}`);
        return resultado;
    };
}

// Función simple de suma
function sumar(a, b) {
    return a + b;
}

// Aplicar el decorador
const sumarConLog = conLog(sumar);

// Pruebas
sumarConLog(3, 4); // Logs + retorna 7
sumarConLog(10, 5); // Logs + retorna 15

// También funciona con arrow functions
const multiplicar = (a, b) => a * b;
const multiplicarConLog = conLog(multiplicar);
multiplicarConLog(3, 7); // Logs + retorna 21
                            
                        

                            
// Función que crea un contador con closure
function crearContador(valorInicial = 0) {
    let contador = valorInicial; // Variable privada

    return {
        incrementar: function() {
            contador++;
            return contador;
        },
        decrementar: function() {
            contador--;
            return contador;
        },
        obtenerValor: function() {
            return contador;
        },
        reset: function() {
            contador = valorInicial;
            return contador;
        }
    };
}

// Crear contadores independientes
const contador1 = crearContador();
const contador2 = crearContador(10);

// Pruebas
console.log(contador1.obtenerValor()); // 0
console.log(contador1.incrementar()); // 1
console.log(contador1.incrementar()); // 2

console.log(contador2.obtenerValor()); // 10
console.log(contador2.decrementar()); // 9

// Los contadores son independientes
console.log(contador1.obtenerValor()); // 2 (sin cambios)
                            
                        

                            
// Módulo de cuenta bancaria con closures
function crearCuenta(saldoInicial = 0) {
    let saldo = saldoInicial;
    let historial = [];

    // Función privada para registrar transacciones
    function registrarTransaccion(tipo, monto, saldoAnterior) {
        historial.push({
            fecha: new Date().toLocaleString(),
            tipo: tipo,
            monto: monto,
            saldoAnterior: saldoAnterior,
            saldoNuevo: saldo
        });
    }

    return {
        depositar: function(monto) {
            if (monto <= 0) {
                return "El monto debe ser positivo";
            }
            const saldoAnterior = saldo;
            saldo += monto;
            registrarTransaccion("Depósito", monto, saldoAnterior);
            return `Depósito exitoso. Nuevo saldo: $${saldo}`;
        },

        retirar: function(monto) {
            if (monto <= 0) {
                return "El monto debe ser positivo";
            }
            if (monto > saldo) {
                return "Fondos insuficientes";
            }
            const saldoAnterior = saldo;
            saldo -= monto;
            registrarTransaccion("Retiro", monto, saldoAnterior);
            return `Retiro exitoso. Nuevo saldo: $${saldo}`;
        },

        consultarSaldo: function() {
            return `Saldo actual: $${saldo}`;
        },

        obtenerHistorial: function() {
            return [...historial]; // Retorna copia del historial
        }
    };
}

// Crear cuenta
const miCuenta = crearCuenta(1000);

// Pruebas
console.log(miCuenta.consultarSaldo()); // Saldo actual: $1000
console.log(miCuenta.depositar(500)); // Depósito exitoso...
console.log(miCuenta.retirar(200)); // Retiro exitoso...
console.log(miCuenta.retirar(2000)); // Fondos insuficientes
console.log(miCuenta.consultarSaldo()); // Saldo actual: $1300

// Ver historial
console.log("Historial de transacciones:");
console.log(miCuenta.obtenerHistorial());