Funciones puras
Una función es pura si cumple dos condiciones:
- Con los mismos argumentos, devuelve siempre lo mismo.
- No tiene efectos secundarios: no modifica nada fuera de ella.
// Pura: solo depende de sus argumentos
const conDescuento = (precio, porcentaje) => precio * (1 - porcentaje / 100);
// Impura: depende de una variable externa que puede cambiar
let descuentoGlobal = 10;
const conDescuentoGlobal = (precio) => precio * (1 - descuentoGlobal / 100);
console.log(conDescuento(100, 10));
console.log(conDescuentoGlobal(100));
descuentoGlobal = 50;
console.log(conDescuentoGlobal(100)); // mismo argumento, otro resultado
Los efectos secundarios son modificar argumentos o variables externas, imprimir, guardar datos, hacer peticiones… Un programa sin ellos no serviría para nada. La idea no es eliminarlos, sino concentrarlos en pocos lugares y mantener puro todo lo demás.
No mutar
Una función pura no modifica lo que recibe: devuelve un valor nuevo.
// Mutante: cambia el array de quien la llama
function agregarMal(lista, item) {
lista.push(item);
return lista;
}
// Pura: devuelve un array nuevo
const agregar = (lista, item) => [...lista, item];
const original = ["pan"];
const nueva = agregar(original, "leche");
console.log(original, nueva);
map, filter y reduce
Los tres métodos estrella para transformar listas sin bucles ni mutaciones:
map(fn): transforma cada elemento. Devuelve un array del mismo largo.filter(fn): se queda con los elementos para los quefndevuelvetrue.reduce(fn, inicial): combina todos los elementos en un solo valor.
const productos = [
{ nombre: "Teclado", precio: 45, stock: 3 },
{ nombre: "Ratón", precio: 20, stock: 0 },
{ nombre: "Monitor", precio: 180, stock: 5 },
];
const disponibles = productos
.filter((p) => p.stock > 0)
.map((p) => p.nombre);
const valorInventario = productos.reduce((total, p) => total + p.precio * p.stock, 0);
console.log(disponibles);
console.log(valorInventario);
Cada paso devuelve un array nuevo, así que se pueden encadenar, y la cadena se lee de arriba abajo como una receta.
Componer funciones
Componer es unir funciones pequeñas para que la salida de una sea la entrada de la siguiente. Con una función auxiliar pipe, que aplica una lista de funciones en orden, quedan transformaciones muy legibles:
const pipe = (...fns) => (valor) => fns.reduce((acum, fn) => fn(acum), valor);
const limpiar = (t) => t.trim();
const minusculas = (t) => t.toLowerCase();
const aSlug = (t) => t.replaceAll(" ", "-");
const crearSlug = pipe(limpiar, minusculas, aSlug);
console.log(crearSlug(" Hola Mundo JS "));
Aplicación parcial
Una función que devuelve otra te deja fijar algunos argumentos de antemano y completar el resto después. Es la idea de las fábricas que viste en Closures:
const multiplicar = (a) => (b) => a * b;
const doble = multiplicar(2);
const triple = multiplicar(3);
console.log([1, 2, 3].map(doble));
console.log([1, 2, 3].map(triple));
Resumen
- Una función pura depende solo de sus argumentos y no cambia nada de afuera.
- Concentra los efectos secundarios en pocos lugares; mantén puro el resto.
- No mutes: devuelve valores nuevos con spread,
map,filter,toSorted… maptransforma,filterselecciona,reducecombina. Siempre con valor inicial enreduce.- Componer y aplicar parcialmente construyen funciones complejas a partir de piezas simples.
¡A practicar!
Tu progreso se guarda en este navegador.
Autoevaluación: Funciones puras y datos que no cambian
Resuelto
Elige una respuesta en cada pregunta.
¿Qué es una función pura?
¿Cuál de estas es un efecto secundario?
¿Qué hace
reduce?¿Qué es componer funciones?
Ordena la salida: filter, map, reduce y componer
Resuelto
Una cadena de transformaciones, una suma y una composición. Ordena lo que aparecería en la consola.
1const numeros = [1, 2, 3, 4];2 3const resultado = numeros.filter((n) => n % 2 === 0).map((n) => n * 10);4const suma = numeros.reduce((acum, n) => acum + n, 0);5const componer = (f, g) => (x) => f(g(x));6 7console.log(resultado.join(","));8console.log(suma);9console.log(numeros.join(","));10console.log(componer((x) => x + 1, (x) => x * 2)(5));Consola, de arriba abajo
- 1,2,3,4
- 11
- 20,40
- 10
filter deja los pares y map los multiplica. reduce los suma partiendo de 0. Ninguno modificó numeros. componer aplica primero g (5 * 2 = 10) y después f (10 + 1).
Detective: Reducir una lista vacía
Resuelto
El total funciona con un carrito lleno, pero no con uno vacío. Encuentra la línea y elige el arreglo.
Consola
15
carrito.js:2
return precios.reduce((acum, p) => acum + p);
^
TypeError: Reduce of empty array with no initial valuePaso 1: toca la línea de código que causa el error.
Paso 2: ¿cómo lo arreglas?
Laboratorio: Total cobrado, sin bucles
Resuelto
Escribe totalCobrado encadenando filter, map y reduce, sin bucles.
$ node programa.js
Lo que debe cumplir
- Imprime
50(pendiente) - Con una lista vacía devuelve
0(pendiente) - Usa
filteryreduce, sinforniwhile(pendiente)
Una solución
1const pedidos = [2 { cliente: "Ana", total: 30, pagado: true },3 { cliente: "Luis", total: 50, pagado: false },4 { cliente: "Eva", total: 20, pagado: true },5];6 7function totalCobrado(lista) {8 return lista9 .filter((p) => p.pagado)10 .map((p) => p.total)11 .reduce((suma, t) => suma + t, 0);12}13 14console.log(totalCobrado(pedidos));Cada paso de la cadena hace una sola cosa y devuelve un array nuevo: quedarse con los pagados, sacar los totales, sumarlos. Se lee casi como una frase, y la función es pura: no toca pedidos ni nada de afuera.