JavaScript Academy · Lezione

Stile point-free

Componi le funzioni senza nominare gli argomenti.

Stile point-free è una lezione JavaScript Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento JavaScript Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso JavaScript Academy include 4 lezioni in totale.

Che cos'è lo stile point-free

Lo stile point-free (o tacito) definisce le funzioni combinandone altre, senza menzionare i relativi argomenti. Gli argomenti sono i punti impliciti che vengono passati lungo la composizione.

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]

Passare direttamente le funzioni

Quando un callback si limita a passare il proprio argomento a un'altra funzione, può passare direttamente quella funzione per nome invece di racchiuderla in un'altra funzione.

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]

Composizione di funzioni

Il codice point-free si basa sulla composizione: costruire una nuova funzione passando l'output di una funzione a quella successiva.

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 legge da sinistra a destra, cosa che molti trovano più chiara rispetto a compose. Applica le funzioni nell'ordine indicato.

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

Costruire pipeline

Con pipe può esprimere una trasformazione in più passaggi come funzione con nome, senza mai nominare i dati.

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"

Il currying abilita lo stile point-free

Il currying trasforma una funzione con più argomenti in una catena di funzioni con un solo argomento. In questo modo produce funzioni unarie pronte per la composizione.

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

Applicazione parziale

Fissare in anticipo alcuni argomenti produce una funzione specializzata che può passare direttamente, offrendo un altro percorso verso il codice point-free.

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

Comporre predicati

Può costruire helper booleani a partire da altri helper, ottenendo filtri point-free chiari e senza il rumore delle arrow function inline.

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]

Compromessi in termini di leggibilità

Lo stile point-free può essere elegante, ma se portato all'estremo diventa criptico. Lo utilizzi quando chiarisce l'intento (map(double)) e mantenga gli argomenti espliciti quando nominarli facilita la comprensione.

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

Insidia dei riferimenti ai metodi

Passare un metodo per nome può fargli perdere il proprio this. Lo racchiuda in una funzione o lo leghi con bind quando la funzione dipende dal contesto di un oggetto.

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

Comporre trasformazioni reali

Mettendo insieme questi concetti, piccole funzioni con nome composte in una pipeline offrono un flusso di dati dichiarativo, testabile e 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

Verifica rapida

Stile point-free.

Riepilogo

Lo stile point-free costruisce funzioni componendone altre senza nominare gli argomenti. Passi le funzioni per riferimento (map(double)), componga con compose/pipe e utilizzi il currying o l'applicazione parziale per creare funzioni unarie. Faccia attenzione alla perdita di this nei riferimenti ai metodi e mantenga gli argomenti espliciti quando il risultato è più chiaro.

Domande Frequenti

La lezione «Stile point-free» è gratuita?

Sì — il testo completo di «Stile point-free» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso JavaScript Academy, passa a CoddyKit PRO. Il corso JavaScript Academy include 4 lezioni in totale.

Cosa imparerò in «Stile point-free»?

Componi le funzioni senza nominare gli argomenti. Eserciti JavaScript Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare JavaScript Academy?

Non è richiesta alcuna esperienza precedente. JavaScript Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Stile point-free»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione JavaScript Academy?

Sì. Ogni lezione JavaScript Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a JavaScript Academy