Introducción a la Programación Funcional en JavaScript

La programación funcional es un paradigma de programación que trata la computación como la evaluación de funciones matemáticas y evita el cambio de estado y los datos mutables. En JavaScript, podemos aplicar estos conceptos para escribir código más limpio, predecible y fácil de probar.

Conceptos Fundamentales

Inmutabilidad

La inmutabilidad significa que una vez que un objeto es creado, no puede ser modificado. En lugar de modificar objetos existentes, creamos nuevas versiones con los cambios deseados.

// ❌ Mutación
const numbers = [1, 2, 3];
numbers.push(4);

// ✅ Inmutabilidad
const numbers = [1, 2, 3];
const newNumbers = [...numbers, 4];

Funciones Puras

Una función pura es aquella que:

1. Dado el mismo input, siempre retorna el mismo output
2. No tiene efectos secundarios

// ❌ Función impura
let total = 0;
const addToTotal = (num) => {
  total += num;
  return total;
};

// ✅ Función pura
const add = (a, b) => a + b;

Higher-Order Functions

Son funciones que pueden tomar otras funciones como argumentos o retornar funciones.

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

// map es una higher-order function
const doubled = numbers.map((num) => num * 2);
console.log(doubled); // [2, 4, 6, 8, 10]

// filter es otra higher-order function
const evenNumbers = numbers.filter((num) => num % 2 === 0);
console.log(evenNumbers); // [2, 4]

Ventajas de la Programación Funcional

1. Código más predecible: Al usar funciones puras e inmutabilidad, el comportamiento del código es más fácil de predecir.
2. Facilidad de testing: Las funciones puras son más fáciles de probar porque no dependen del estado global.
3. Mejor mantenibilidad: El código funcional tiende a ser más declarativo y modular.

Ejemplo Práctico

Veamos un ejemplo que combina varios conceptos de programación funcional:

// Datos de ejemplo
const products = [
  { id: 1, name: "Laptop", price: 1000, category: "Electronics" },
  { id: 2, name: "Book", price: 20, category: "Books" },
  { id: 3, name: "Phone", price: 500, category: "Electronics" },
];

// Funciones puras para manipular los datos
const filterByCategory = (category) => (products) =>
  products.filter((product) => product.category === category);

const applyDiscount = (percentage) => (product) => ({
  ...product,
  price: product.price * (1 - percentage / 100),
});

// Composición de funciones
const getDiscountedElectronics = (products) => {
  const electronicsOnly = filterByCategory("Electronics")(products);
  return electronicsOnly.map(applyDiscount(10));
};

// Uso
const discountedElectronics = getDiscountedElectronics(products);
console.log(discountedElectronics);

Conclusión

La programación funcional nos ofrece herramientas poderosas para escribir código más mantenible y menos propenso a errores. Aunque JavaScript no es un lenguaje puramente funcional, podemos aprovechar muchos de estos conceptos para mejorar nuestro código.

Recuerda:

• Preferir la inmutabilidad
• Escribir funciones puras cuando sea posible
• Aprovechar las higher-order functions
• Pensar en términos de transformación de datos en lugar de mutación

¡Feliz codificación funcional! 🚀