Programación funcional en JavaScript: fundamentos y ejemplos

Programación funcional en JavaScript: de la teoría a la práctica

La programación funcional (PF) es un paradigma que considera los cálculos como la evaluación de funciones matemáticas y evita el cambio de estado y los datos mutables. En JavaScript moderno, especialmente en el entorno Node.js, el enfoque funcional se vuelve cada vez más popular debido a su previsibilidad, capacidad de prueba y modularidad. En este artículo, analizaremos los conceptos clave de la PF y mostraremos cómo aplicarlos en proyectos reales.

1. Funciones puras y ausencia de efectos secundarios

Una función pura es una función que:

• Siempre devuelve el mismo resultado para los mismos argumentos (determinismo).
• No causa efectos secundarios (no modifica variables externas, no genera salida de datos, no accede al sistema de archivos).

Ejemplo de función pura:

// Función pura: suma dos númerosconst add = (a, b) => a + b;

console.log(add(2, 3)); // 5console.log(add(2, 3)); // 5 — siempre igual

Ejemplo de función impura:

let counter = 0;const increment = () => {    counter++; // Efecto secundario: modifica una variable externa    return counter;};

console.log(increment()); // 1console.log(increment()); // 2 — resultado diferente

En programación funcional, nos esforzamos por escribir solo funciones puras. Esto hace que el código sea más fácil de probar y depurar.

2. Inmutabilidad de los datos

La inmutabilidad significa que los datos no cambian después de su creación. En lugar de modificar un objeto existente, creamos una nueva copia con los cambios necesarios. En JavaScript, para esto se suele usar el operador spread (...) o el método Object.assign.

Ejemplo de actualización inmutable de un objeto:

const user = { name: 'Alice', age: 30 };

// Mal: mutaciónuser.age = 31;

// Bien: creamos un nuevo objetoconst updatedUser = { ...user, age: 31 };

console.log(user);        // { name: 'Alice', age: 30 }console.log(updatedUser); // { name: 'Alice', age: 31 }

Para arrays también usamos métodos inmutables:

const numbers = [1, 2, 3];

// Mutación (mal)numbers.push(4);

// Inmutable (bien)const newNumbers = [...numbers, 4];

console.log(numbers);    // [1, 2, 3]console.log(newNumbers); // [1, 2, 3, 4]

3. Funciones de orden superior: map, filter, reduce

Las funciones de orden superior son funciones que toman otras funciones como argumentos o las devuelven. Los tres métodos más populares en JavaScript son map, filter y reduce. Permiten procesar arrays sin bucles ni mutaciones.

3.1. map() — transformación de array

El método map crea un nuevo array aplicando una función a cada elemento del array original.

const prices = [100, 200, 300];const withTax = prices.map(price => price * 1.2);

console.log(withTax); // [120, 240, 360]// El array original no ha cambiadoconsole.log(prices);  // [100, 200, 300]

3.2. filter() — filtrado de array

El método filter devuelve un nuevo array que contiene solo aquellos elementos para los cuales la función pasada devolvió true.

const ages = [15, 22, 18, 30, 12];const adults = ages.filter(age => age >= 18);

console.log(adults); // [22, 18, 30]

3.3. reduce() — agregación de datos

El método reduce reduce un array a un solo valor (número, objeto, cadena).

const numbers = [1, 2, 3, 4, 5];const sum = numbers.reduce((accumulator, current) => accumulator + current, 0);

console.log(sum); // 15

Combinando estos métodos, se pueden resolver problemas complejos en estilo funcional:

const users = [