Funzioni di ordine superiore

5.1 Concetti base

Le funzioni di ordine superiore sono un aspetto importante della programmazione funzionale e sono ampiamente usate in JavaScript. Permettono di scrivere codice più astratto, compatto e riutilizzabile.

Cosa sono le funzioni di ordine superiore?

Le funzioni di ordine superiore (higher-order functions) sono funzioni che accettano altre funzioni come argomenti o restituiscono funzioni come risultato. Permettono di usare le funzioni come oggetti di prima classe, offrendo la possibilità di creare programmi più astratti e modulari.

Esempi di funzioni di ordine superiore

1. Passare funzioni come argomenti.
2. Restituire funzioni da altre funzioni.

5.2 Passare funzioni come argomenti

Uso dei metodi predefiniti degli array

JavaScript fornisce molti metodi predefiniti per lavorare con gli array, che sono funzioni di ordine superiore, come forEach(), map(), filter(), reduce() e altri.

1. Metodo forEach()

Il metodo forEach() esegue la funzione specificata una volta per ogni elemento dell'array.

    
      const numbers = [1, 2, 3, 4, 5];

      numbers.forEach(function(number) {
        console.log(number);
      });
      // Stampa: 1 2 3 4 5
    
  

2. Metodo map()

Il metodo map() crea un nuovo array con i risultati della chiamata della funzione specificata per ogni elemento dell'array.

    
      const numbers = [1, 2, 3, 4, 5];
      const squaredNumbers = numbers.map(function(number) {
        return number * number;
      });

      console.log(squaredNumbers);
      // Stampa: [1, 4, 9, 16, 25]
    
  

3. Metodo filter()

Il metodo filter() crea un nuovo array con tutti gli elementi che superano il test specificato nella funzione passata.

    
      const numbers = [1, 2, 3, 4, 5];
      const evenNumbers = numbers.filter(function(number) {
        return number % 2 === 0;
      });

      console.log(evenNumbers);
      // Stampa: [2, 4]
    
  

4. Metodo reduce()

Il metodo reduce() applica la funzione ad un accumulatore e ad ogni elemento dell'array (da sinistra a destra), riducendo tutto ad un unico valore.

    
      const numbers = [1, 2, 3, 4, 5];
      const sum = numbers.reduce(function(total, number) {
        return total + number;
      }, 0);

      console.log(sum);
      // Stampa: 15
    
  

5.3 Restituire funzioni da altre funzioni

Le funzioni di ordine superiore possono restituire altre funzioni, permettendo di creare funzioni più flessibili e configurabili.

1. Currying

Il currying è il processo di trasformare una funzione che accetta diversi argomenti in una funzione che accetta un solo argomento e restituisce una nuova funzione che accetta il successivo argomento e così via.

Esempio di currying:

    
      function multiply(a) {
        return function(b) {
          return a * b;
        };
      }

      const multiplyByTwo = multiply(2);
      console.log(multiplyByTwo(5)); // Stampa: 10

      const multiplyByThree = multiply(3);
      console.log(multiplyByThree(5)); // Stampa: 15
    
  

2. Creare funzioni personalizzabili

Le funzioni di ordine superiore permettono di creare funzioni che possono essere personalizzate con argomenti.

Esempio:

    
      function createGreeting(greeting) {
        return function(name) {
          console.log(`${greeting}, ${name}!`);
        };
      }

      const sayHello = createGreeting('Hello');
      sayHello('Alice'); // Stampa: Hello, Alice!

      const sayHi = createGreeting('Hi');
      sayHi('Bob'); // Stampa: Hi, Bob!
    
  

5.4 Applicazione pratica

Vediamo l'applicazione pratica delle funzioni di ordine superiore.

La funzione compose()

La funzione compose() permette di combinare diverse funzioni in una sola, che le applica in sequenza:

    
      function compose(...functions) {
        return function(initialValue) {
          return functions.reduceRight((value, func) => func(value), initialValue);
        };
      }

      const addOne = x => x + 1;
      const double = x => x * 2;
      const addOneAndDouble = compose(double, addOne);
      console.log(addOneAndDouble(5)); // Stampa: 12 (prima aggiunge 1 a 5, poi raddoppia il risultato)
    
  

Funzioni di ordine superiore asincrone

Le funzioni di ordine superiore asincrone permettono di lavorare con operazioni asincrone, come le richieste API o il lavoro con i timer:

    
      function fetchData(callback) {
        setTimeout(() => {
          callback('Data received');
        }, 1000);
      }

      function processData(data) {
        console.log(data);
      }

      fetchData(processData);
      // Stampa: Data received (dopo 1 secondo)