JavaScript Academy · Lección

Estilo point-free

Componga funciones sin nombrar los argumentos.

Estilo point-free es una lección gratuita de JavaScript Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de JavaScript Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de JavaScript Academy incluye 4 lecciones en total.

Qué es el estilo point-free

El estilo point-free (o tácito) define funciones combinando otras funciones, sin mencionar sus argumentos. Los argumentos son los puntos implícitos que se van pasando.

function double(n) { return n * 2; }
const nums = [1, 2, 3];
// pointed: argument named explicitly
console.log(nums.map((n) => double(n))); // [2, 4, 6]
// point-free: no named argument
console.log(nums.map(double));            // [2, 4, 6]

Pasar funciones directamente

Cuando un callback simplemente pasa su argumento a otra función, puede pasar esa función por nombre en lugar de envolverla.

const len = (s) => s.length;
const words = ["a", "bb", "ccc"];
console.log(words.map((w) => w.length)); // pointed: [1, 2, 3]
console.log(words.map(len));             // point-free: [1, 2, 3]

Composición de funciones

El código point-free se apoya en la composición: crear una función nueva pasando la salida de una función a la siguiente.

const compose = (f, g) => (x) => f(g(x));
const inc = (n) => n + 1;
const double = (n) => n * 2;
const incThenDouble = compose(double, inc);
console.log(incThenDouble(3)); // (3+1)*2 = 8

Un helper pipe

pipe se lee de izquierda a derecha, lo que a muchas personas les resulta más claro que compose. Aplica las funciones en orden.

const pipe = (...fns) => (x) => fns.reduce((acc, f) => f(acc), x);
const inc = (n) => n + 1;
const double = (n) => n * 2;
const f = pipe(inc, double);
console.log(f(3)); // 8

Crear pipelines

Con pipe puede expresar una transformación de varios pasos como una función con nombre sin nombrar nunca los datos.

const pipe = (...fns) => (x) => fns.reduce((a, f) => f(a), x);
const trim = (s) => s.trim();
const lower = (s) => s.toLowerCase();
const clean = pipe(trim, lower);
console.log(clean("  HELLO  ")); // "hello"

Currying permite usar point-free

Currying convierte una función con varios argumentos en una cadena de funciones con un solo argumento. Esto produce funciones unarias listas para componer.

const multiply = (a) => (b) => a * b;
const triple = multiply(3);
console.log([1, 2, 3].map(triple)); // [3, 6, 9]

Aplicación parcial

Fijar algunos argumentos de antemano produce una función especializada que puede pasar directamente, otra forma de escribir código point-free.

const add = (a, b) => a + b;
const add10 = add.bind(null, 10);
console.log([1, 2, 3].map(add10)); // [11, 12, 13]

Componer predicados

Puede construir helpers booleanos a partir de otros para crear filtros point-free claros, sin el ruido de las funciones flecha en línea.

const isEven = (n) => n % 2 === 0;
const negate = (fn) => (x) => !fn(x);
const isOdd = negate(isEven);
console.log([1, 2, 3, 4].filter(isOdd)); // [1, 3]

Compromisos de legibilidad

Point-free puede resultar elegante, pero llevado demasiado lejos se vuelve críptico. Úselo cuando aclare la intención (map(double)) y mantenga los argumentos explícitos cuando nombrarlos facilite la comprensión.

const names = ["ada", "bob"];
console.log(names.map((n) => n.toUpperCase())); // ["ADA","BOB"]

El inconveniente de las referencias a métodos

Pasar un método por nombre puede hacer que pierda su this. Envuélvalo o vincúlelo cuando la función dependa del contexto de un objeto.

const calc = {
  factor: 2,
  scale(n) { return n * this.factor; }
};
console.log([1, 2].map(calc.scale.bind(calc))); // [2, 4]

Componer transformaciones reales

Al combinarlo todo, las funciones pequeñas con nombre, compuestas en un pipeline, proporcionan un flujo de datos declarativo, comprobable y point-free.

const pipe = (...fns) => (x) => fns.reduce((a, f) => f(a), x);
const toNums = (arr) => arr.map(Number);
const onlyPos = (arr) => arr.filter((n) => n > 0);
const sum = (arr) => arr.reduce((a, n) => a + n, 0);
const process = pipe(toNums, onlyPos, sum);
console.log(process(["3", "-1", "4"])); // 7

Comprobación rápida

Estilo point-free.

Resumen

El estilo point-free crea funciones componiendo otras sin nombrar los argumentos. Pase funciones por referencia (map(double)), compóngalas con compose/pipe y use currying o aplicación parcial para crear funciones unarias. Tenga cuidado de no perder this en las referencias a métodos y mantenga los argumentos explícitos cuando resulte más claro.

Preguntas frecuentes

¿La lección «Estilo point-free» es gratis?

Sí — el texto completo de «Estilo point-free» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de JavaScript Academy, actualiza a CoddyKit PRO. El curso de JavaScript Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Estilo point-free»?

Componga funciones sin nombrar los argumentos. Practicas JavaScript Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar JavaScript Academy?

No se requiere experiencia previa. JavaScript Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Estilo point-free»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de JavaScript Academy?

Sí. Cada lección de JavaScript Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a JavaScript Academy