Saltar al contenido
Funciones

Estilo funcional

Lección 5 de 511 min4 ejercicios

El estilo funcional es una forma de escribir programas como una cadena de transformaciones: tomas datos, les aplicas funciones pequeñas que no cambian nada a su alrededor, y obtienes datos nuevos. No es una regla que haya que seguir siempre, sino una caja de herramientas que hace el código más predecible y fácil de probar.

Funciones puras

Una función es pura si cumple dos condiciones:

  1. Con los mismos argumentos, devuelve siempre lo mismo.
  2. 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 que fn devuelve true.
  • 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…
  • map transforma, filter selecciona, reduce combina. Siempre con valor inicial en reduce.
  • 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

Elige una respuesta en cada pregunta.

  1. ¿Qué es una función pura?

  2. ¿Cuál de estas es un efecto secundario?

  3. ¿Qué hace reduce?

  4. ¿Qué es componer funciones?

Ordena la salida: filter, map, reduce y componer

Una cadena de transformaciones, una suma y una composición. Ordena lo que aparecería en la consola.

const numeros = [1, 2, 3, 4]; const resultado = numeros.filter((n) => n % 2 === 0).map((n) => n * 10);const suma = numeros.reduce((acum, n) => acum + n, 0);const componer = (f, g) => (x) => f(g(x)); console.log(resultado.join(","));console.log(suma);console.log(numeros.join(","));console.log(componer((x) => x + 1, (x) => x * 2)(5));

Consola, de arriba abajo

  1. 1,2,3,4
  2. 11
  3. 20,40
  4. 10

Detective: Reducir una lista vacía

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 value

Paso 1: toca la línea de código que causa el error.

Laboratorio: Total cobrado, sin bucles

Escribe totalCobrado encadenando filter, map y reduce, sin bucles.

programa.jsse ejecuta mientras escribes

$ node programa.js

(escribe tu código: se ejecuta solo)

Lo que debe cumplir

  • Imprime 50 (pendiente)
  • Con una lista vacía devuelve 0 (pendiente)
  • Usa filter y reduce, sin for ni while (pendiente)

    domina-js · JavaScript en español, gratis y paso a paso.