I vantaggi della programmazione funzionale

La programmazione funzionale è un paradigma di programmazione che si basa sul concetto di funzioni pure e sull'immutabilità dei dati. Negli ultimi anni, ha guadagnato popolarità grazie ai suoi numerosi vantaggi rispetto ai paradigmi imperativi e orientati agli oggetti, puoi approfondirne gli aspetti nell'articolo Conosci la Programmazione Funzionale?.

In questo articolo, vedremo come bisogna ragionare quando iniziamo a scrivere codice con questo paradigma di programmazione.

🔗 Ti piace Techelopment? Dai un’occhiata al sito per tutti i dettagli!

Ciclo `for` in modo tradizionale

Immagina di avere un array di oggetti JSON che rappresentano delle persone. Ecco un esempio di come si può iterare su di esso usando un ciclo for:


const persons = [
    { name: "Francesco", age: 30 },
    { name: "Gabriella", age: 25 },
    { name: "Jennifer", age: 35 },
    { name: "Arnold", age: 40 },
];

// Using a traditional for loop
for (let i = 0; i < persons.length; i++) {
    console.log(`Name: ${persons[i].name}, Age: ${persons[i].age}`);
}

In questo esempio, il ciclo for scorre manualmente l'array e stampa il nome e l'età di ogni persona. Questo è il metodo tradizionale e richiede di gestire esplicitamente l'indice.

Utilizzando `forEach` (Programmazione Funzionale)

Ora vediamo come si può ottenere lo stesso risultato, ma con un approccio più funzionale, utilizzando il metodo forEach. Questo è un esempio tipico della programmazione funzionale in JavaScript, che rende il codice più leggibile e conciso.


const persons = [
    { name: "Francesco", age: 30 },
    { name: "Gabriella", age: 25 },
    { name: "Jennifer", age: 35 },
    { name: "Arnold", age: 40 },
];
  
// Using forEach (Functional Programming)
persons.forEach(person => console.log(`Name: ${person.name}, Age: ${person.age}`));

In questo caso, forEach è un metodo di array che itera automaticamente sugli elementi dell'array. Non è necessario preoccuparsi degli indici o del ciclo esplicito. Il codice è più pulito e conciso, e segue meglio i principi della programmazione funzionale.

Confronto

Con il ciclo for: Devi gestire manualmente l'indice e iterare su ogni elemento, il che può rendere il codice più verboso e soggetto a errori.
Con forEach: La funzione callback è più concisa (grazie anche alle arrow functions) e l'iterazione è gestita automaticamente. Il codice risulta più leggibile e funzionale.

Questi esempi dimostrano come la programmazione funzionale, grazie a metodi come forEach, possa semplificare il codice e renderlo più leggibile.

Evoluzione

Immagina ora che, in seguito ad un update software, l'array persons debba essere aggiornato per includere una nuova proprietà gender. Di conseguenza, il nostro programma dovrà stampare solo le persone di sesso femminile escludendo tutte quelle di genere maschile.

Vediamo come il nostro software dovrebbe evolversi.

Approccio non funzionale (immediato, ma non ottimale)

Un programmatore che non è abituato alla programmazione funzionale potrebbe semplicemente aggiungere una condizione all'interno del forEach per escludere le persone di genere "male". Ecco come potrebbe fare:


const persons = [
    { name: "Francesco", age: 30, gender: "male" },
    { name: "Gabriella", age: 25, gender: "female" },
    { name: "Jennifer", age: 35, gender: "female" },
    { name: "Arnold", age: 40, gender: "male" },
];
  

// Using forEach with a condition to exclude 'male'
persons.forEach(person => {
  if (person.gender !== 'male') {
    console.log(`Name: ${person.name}, Age: ${person.age}, Gender: ${person.gender}`);
  }
});

In questo esempio, l'operatore if all'interno del forEach esclude manualmente le persone di genere "male". Mentre questo approccio funziona, non è l'ideale perché si sta mescolando la logica di filtraggio con la logica di iterazione. Il codice potrebbe risultare meno chiaro, specialmente se il numero di condizioni aumenta o se il codice cresce.

Inoltre, in casi più complessi, mescolare programmazione funzionale (forEach) con programmazione imperativa (if all'interno del forEach) potrebbe addirittura non dare i risultati sperati a causa di side-effect o di scope di esecuzione (ricorda che forEach è un wrapper che prende in input funzioni) che potrebbe sovrascrivere variabili e valori.

Approccio funzionale (più elegante, con separazione dei concetti e sicuro)

Un approccio più adeguato alla programmazione funzionale è separare la logica di filtraggio dalla logica di iterazione. In questo caso, si può utilizzare il metodo .filter() prima di chiamare forEach per escludere direttamente le persone di genere "male".

Questo approccio rende il codice più leggibile, modulare e aderente ai principi funzionali. Inoltre, in questo modo evitiamo possibili side-effect dovuti ad approcci di programmazione differenti (es. functional programming vs imperative programming).


const persons = [
    { name: "Francesco", age: 30, gender: "male" },
    { name: "Gabriella", age: 25, gender: "female" },
    { name: "Jennifer", age: 35, gender: "female" },
    { name: "Arnold", age: 40, gender: "male" },
];

persons
  .filter(person => person.gender !== 'male')  // filter out persons of gender "male"
  .forEach(person => {
    console.log(`Name: ${person.name}, Age: ${person.age}, Gender: ${person.gender}`);
  });

Spiegazione del codice funzionale

.filter(): Prima di tutto, utilizziamo il metodo filter() per creare un nuovo array che contiene solo le persone il cui gender non è "male". Il filtro è chiaro e separato dalla logica di iterazione.
.forEach(): Poi, dopo aver applicato il filtro, utilizziamo forEach() per iterare solo sulle persone che soddisfano il filtro. Questo rende il codice più leggibile, facile da mantenere, e più dichiarativo.

Vantaggi dell'approccio funzionale:

Separazione dei compiti: Si separa la logica di filtraggio dalla logica di iterazione. La funzione filter() è chiaramente responsabile del filtraggio, mentre forEach() si occupa solo dell'iterazione. Questo rende il codice più modulare e comprensibile.
Concisenza e leggibilità: Il codice è più conciso e chiaro, senza dover inserire condizioni all'interno del ciclo. L'intento è immediatamente comprensibile, e si segue il flusso funzionale naturale (filtraggio, poi iterazione).
Più flessibilità: Se in futuro volessi cambiare la condizione di filtro (ad esempio, escludere un altro genere o aggiungere altre condizioni), sarebbe sufficiente modificare la parte filter(), senza toccare la logica di iterazione.
Nessun side-effect: L'utilizzo della programmazione funzionale offre un maggior livello di affidabilità nel ridurre il rischio di side-effect nel codice dovuti a potenziali override di variabili o problemi di scope.

In generale, l'approccio funzionale è più scalabile e facilmente manutenibile.

Follow me #techelopment

Official site: www.techelopment.it
facebook: Techelopment
instagram: @techelopment
X: techelopment
Bluesky: @techelopment
telegram: @techelopment_channel
whatsapp: Techelopment
youtube: @techelopment

Techelopment

Cerca nel blog