Programación funcional en JavaScript: de la A a la Z para Node.js

Programación funcional en JavaScript: de la A a la Z

La programación funcional (PF) es un paradigma que considera los cálculos como la evaluación de funciones matemáticas y evita cambiar el estado y los datos mutables. En el contexto de JavaScript (Node.js), la PF se convierte en una herramienta poderosa para crear código predecible, testeable y escalable. En este artículo, desglosaremos los conceptos clave de la PF desde lo básico hasta técnicas avanzadas, respaldando la teoría con ejemplos prácticos.

Fundamentos: Funciones puras e inmutabilidad

En el corazón de la PF se encuentran dos principios: funciones puras e inmutabilidad (datos inmutables).

Una función pura siempre devuelve el mismo resultado para los mismos argumentos y no tiene efectos secundarios (no modifica variables externas, no imprime en consola, no hace solicitudes a API).

// Función puraconst add = (a, b) => a + b;

// Función impura (efecto secundario: modifica una variable externa)let counter = 0;const increment = () => counter++;

La inmutabilidad significa que los datos no se modifican directamente, sino que se crean nuevas copias con los cambios necesarios. En JavaScript, se utilizan métodos que devuelven nuevos objetos/arrays.

// Actualización inmutable de un objetoconst user = { name: 'Alice', age: 30 };const updatedUser = { ...user, age: 31 }; // Creamos un nuevo objeto

// Actualización inmutable de un arrayconst numbers = [1, 2, 3];const newNumbers = [...numbers, 4]; // [1, 2, 3, 4]

Closures y funciones de orden superior

Un closure es una función que "recuerda" su entorno léxico incluso después de que la función externa haya terminado de ejecutarse. Esta es la base de muchos patrones de PF.

const createMultiplier = (factor) => {  // Función interna — closure  return (number) => number * factor;};

const double = createMultiplier(2);console.log(double(5)); // 10

Las funciones de orden superior son funciones que toman otras funciones como argumentos o las devuelven. Ejemplos clásicos son map, filter, reduce.

const numbers = [1, 2, 3, 4, 5];

// map — transforma cada elementoconst doubled = numbers.map(n => n * 2); // [2, 4, 6, 8, 10]

// filter — selecciona elementos según una condiciónconst even = numbers.filter(n => n % 2 === 0); // [2, 4]

// reduce — reduce el array a un solo valorconst sum = numbers.reduce((acc, n) => acc + n, 0); // 15

Composición de funciones y currying

La composición de funciones es la combinación de varias funciones en una, donde el resultado de una función se pasa como entrada a la siguiente. Esto permite construir operaciones complejas a partir de bloques simples y reutilizables.

const compose = (...fns) => (x) => fns.reduceRight((acc, fn) => fn(acc), x);

const trim = (str) => str.trim();const toLowerCase = (str) => str.toLowerCase();const capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);

const processName = compose(capitalize, toLowerCase, trim);console.log(processName('  JOHN DOE  ')); // 'John doe'

El currying es la transformación de una función con múltiples argumentos en una secuencia de funciones, cada una de las cuales toma un solo argumento. Esto simplifica la aplicación parcial y la composición.

// Función normalconst multiply = (a, b, c) => a * b * c;

// Versión currificadaconst curriedMultiply = (a) => (b) => (c) => a * b * c;

console.log(curriedMultiply(2)(3)(4)); // 24

// Aplicación parcialconst multiplyBy2 = curriedMultiply(2);const multiplyBy2And3 = multiplyBy2(3);console.log(multiplyBy2And3(5)); // 30

Ejemplo práctico: procesamiento de datos en Node.js