introduzione

La programmazione funzionale è un paradigma di programmazione che enfatizza la scrittura di codice utilizzando le funzioni come elementi costitutivi primari. Nella programmazione funzionale, le funzioni sono trattate come cittadini di prima classe, il che significa che possono essere passate come argomenti ad altre funzioni, restituite da funzioni e memorizzate in variabili.

In JavaScript, le funzioni di ordine superiore sono funzioni che possono accettare altre funzioni come argomenti o restituire funzioni come risultato. Due popolari funzioni di ordine superiore utilizzate nella programmazione funzionale sono le funzioni pipe e compose.

Funzione tubo

La funzione pipe è una funzione di ordine superiore che accetta due o più funzioni come argomenti e restituisce una nuova funzione. La funzione restituita accetta un input, vi applica ciascuna delle funzioni fornite in ordine, passando l'output di ciascuna funzione come input alla funzione successiva. L'output finale è il risultato dell'ultima funzione nella pipe.

Ecco un esempio di utilizzo della funzione pipe:

const pipe = (...fns) => (x) => fns.reduce((acc, f) => f(acc), x);

const addFive = (x) => x + 5;
const square = (x) => x * x;
const double = (x) => x * 2;

const result = pipe(addFive, square, double)(2); // Returns 98

console.log(result);

Componi la funzione

La funzione compose è simile alla funzione pipe, ma applica le funzioni nell'ordine opposto. La funzione compose accetta due o più funzioni come argomenti e restituisce una nuova funzione che applica ciascuna funzione in ordine inverso.

Ecco un esempio di utilizzo della funzione Compose:

const compose = (...fns) => (x) => fns.reduceRight((acc, f) => f(acc), x);

const addFive = (x) => x+ 5;
const square = (x) => x * x;
const double = (x) => x * 2;

const result = compose(double, square, addFive)(2); // Returns 98

console.log(result);

Altri esempi

Esistono molti modi per utilizzare le funzioni pipe e compose in JavaScript. Ecco alcuni esempi:

Esempio 1: trasformazione dei dati

Supponiamo di avere un array di oggetti utente e di voler ordinare l'array per età, filtrarlo per includere solo gli utenti con un'età di 25 anni e quindi mappare gli utenti rimanenti ai loro nomi. Possiamo utilizzare le funzioni sort, filtere mapper ottenere questo risultato, ma può essere difficile leggere e comprendere il codice. Invece, possiamo usare la pipefunzione per concatenare queste funzioni insieme:

const users = [
  { name: 'Sumit', age: 38 },
  { name: 'Jasim', age: 30 },
  { name: 'Rahim', age: 20 },
];

const sortByAge = (a, b) => a.age - b.age;
const filterByAge = (age) => (user) => user.age === age;
const mapByName = (user) => user.name;

const result = pipe(
  (users) => users.sort(sortByAge),
  (users) => users.filter(filterByAge(38)),
  (users) => users.map(mapByName)
)(users);

console.log(result); // Returns ['Sumit']

Esempio 2: Composizione di funzioni

Supponiamo di avere due funzioni, ge f, e di voler creare una nuova funzione che si applichi gal risultato di f. Possiamo usare la composefunzione per creare questa nuova funzione:

const g = (x) => x + 1;
const f = (x) => x * 2;

const h = compose(g, f);

console.log(h(3)); // Returns 7

Esempio 3: Redux Middleware

Nella libreria di gestione dello stato Redux, il middleware è una funzione che intercetta le azioni inviate allo store e può modificarle, inviare azioni aggiuntive o eseguire altri effetti collaterali. Le funzioni middleware sono in genere composte insieme utilizzando la composefunzione.

Ecco un esempio di utilizzo della composefunzione per creare un middleware Redux:

const loggerMiddleware = (store) => (next) => (action) => {
  console.log(`Action: ${action.type}, State: ${JSON.stringify(store.getState())}`);
  return next(action);
};

const errorMiddleware = (store) => (next) => (action) => {
  try {
    return next(action);
  } catch (error) {
    console.error(`Error: ${error}`);
    throw error;
  }
};

const middleware = compose(loggerMiddleware, errorMiddleware);

// Usage in Redux store
const store = createStore(reducer, initialState, middleware);

Conclusione

In conclusione, le funzioni pipe e compose sono utili funzioni di ordine superiore per la programmazione funzionale in JavaScript. Consentono di concatenare più funzioni per creare una nuova funzione che applica tutte le funzioni in un'unica operazione. Questo può rendere il tuo codice più leggibile, conciso e componibile.