Che cos'è una funzione pura?
Bene, una funzione pura assomiglia a questa, abbiamo una funzione, quindi invece di una scatola che avevamo prima di oggetti
di tutte queste funzionalità, pensa invece a questo come a una semplice funzione.
E diciamo che gli diamo una lista contenente uno, due e tre.
Se diamo questo input a questa funzione, ciò che ci aspetteremmo da una funzione pura è che succeda qualcosa
a questo input che ogni volta risulta nella stessa cosa.
Quindi diciamo che moltiplichiamo questo per due, otterremmo due, quattro e sei.
Ora, una funzione pura ha due regole.
Uno è che dato lo stesso input, restituirà sempre lo stesso output, ovvero ogni volta che diamo uno, due e tre
a questo elenco, lo diamo a una funzione che creiamo.
Dovrebbe restituire sempre lo stesso output.
Quindi, se eseguo questa funzione milioni di volte con lo stesso input, dovrebbe risultare lo stesso output.
E il secondo punto è che questa idea di una funzione non dovrebbe produrre alcun effetto collaterale.
Quali sono gli effetti collaterali?
Gli effetti collaterali sono cose che funzionano.
Influisce sul mondo esterno?
Ad esempio, se dovessi stampare qualcosa all'interno di questa funzione, influenzerebbe il mondo esterno, giusto?
Perché sto stampando qualcosa su uno schermo.
Lo schermo è il mondo esterno.
Oppure, ad esempio, se questa funzione toccava una variabile che viveva al di fuori di un ambito diverso, si trattava di
un effetto collaterale.
Diamo un'occhiata.
Un codice per capire un po' di più questo concetto.
Diciamo che abbiamo avuto una funzione e poi questa funzione si moltiplicherà.
Passando a una lista, quindi diciamo solo un alleato, che sarà la nostra lista, e qui quello che vogliamo
fare è scorrere l'elemento.
Nell'ultimo.
E poi ogni elemento che vogliamo moltiplicare e aggiungere a un nuovo elenco.
Quindi creiamo un nuovo elenco che sarà un elenco vuoto.
E qui diremo nuova lista, punto aggiungi.
E fallo moltiplicando per due.
E infine, alla fine di questa funzione, vogliamo restituire il nuovo elenco.
Proviamo questo.
Se dico moltiplicare per due e dare uno, due, tre e stampiamo.
Ecco, l'uscita.
Se clicco, corro.
Ne prendo due, quattro, sei.
È una pura funzione, pensiamo a questo.
La prima regola ha lo stesso input, ovvero uno, due e tre.
Restituirà sempre lo stesso output, non importa quante volte lo eseguo, mi darà sempre
lo stesso output.
Quindi, ok, abbiamo superato il primo test.
E il secondo test che non produce effetti collaterali?
Questo produce effetti collaterali?
Questo tocca qualcosa nel mondo esterno?
Pensaci.
No, non scrive nulla nel mondo esterno è importante per questa funzione.
Perché tutto è contenuto qui dentro.
Se, ad esempio, invece di stampare qui, abbiamo semplicemente stampa.
E qui.
Se clicco, corro.
Otteniamo lo stesso risultato, ma questo ha effetti collaterali?
Ebbene sì, lo fa.
Interagisce con il mondo esterno, che è la dichiarazione di stampa.
La dichiarazione di stampa mi dice, ehi, stamperò su qualunque display abbia questa macchina.
Nel nostro caso, verrà stampato qui, ma non sappiamo esattamente cosa fa l'istruzione print perché interagisce
con lo schermo su questo lato.
Così questo.
Effetti collaterali, diamo il controllo alla stampa, ma non sappiamo cosa farà la stampa.
Un altro esempio che posso farti.
È questo che succede se abbiamo una nuova lista qui che in realtà definiamo all'esterno?
Così.
In modo che abbiamo un nuovo elenco come questo, se faccio clic su Esegui.
Arrivo ancora a quattro, sei, ma questo ha effetti collaterali?
Ebbene sì, lo fa.
Interagisce con il mondo esterno e ciò che è al di fuori di questo mondo di una
funzione che ricorda, è lo scopo, beh, interagisce con questo nuovo elenco.
Succede a questa nuova lista.
Quindi se arriva un programmatore e magari prima di eseguire questa funzione, decidiamo di dire nuova lista.
Lo cambiamo in una stringa vuota.
Bene, quando eseguo questa funzione.
Ricevo un errore perché ora questo nuovo elenco è un oggetto stringa.
Quindi il nuovo elenco che vive nel mondo esterno di questa funzione può essere modificato da un altro sviluppatore o
da un programma e non lo sapremmo.
E quando eseguiamo questa funzione, ci darà un errore.
Ha un effetto collaterale.
Quindi, idealmente, conteniamo le nostre funzioni.
E rendili puri, perché, come puoi vedere, non avremo mai un bug o un errore nel nostro codice a meno che
non abbiamo scritto qualcosa di sbagliato qui, ma perché non ci interessa il mondo esterno,
perché tutto ciò che dare come input produrrà sempre un buon output, sarà puro.
Ora, è difficile capire davvero perché questo sia un concetto così potente senza avere un po' di esperienza sul posto
di lavoro.
Ma lascia che ti dica solo questo, quello quando hai funzioni pure.
Hai meno codice con errori, sei in grado di testare meglio il tuo codice.
È più facile capire il tuo codice e in generale.
Hai questi vantaggi di non avere parti diverse del tuo codice, toccarsi e influenzarsi a vicenda, il
che rende la tua vita come programmatore molto più semplice.
Quindi questa idea di funzioni pure è davvero importante.
Ma l'unica cosa che voglio che tragga da questo è che le funzioni pure sono più una linea guida
che un assoluto.
È impossibile avere funzioni pure ovunque perché se una funzione non ha alcun effetto sul mondo esterno,
beh, non avremmo nessun programma.
Non saremmo in grado di mostrare le cose.
Non saremmo in grado di salvare elementi come il nostro profilo di gioco.
Quindi è impossibile avere funzioni pure ovunque.
Tuttavia, quando puoi ovunque puoi, la programmazione funzionale ci insegna che le tue funzioni sono buone.
Cerca di creare funzioni pure e di avere solo poche funzioni non pure che magari interagiscono con il
mondo esterno a cui possiamo tornare ogni volta che abbiamo dei bug nel nostro codice, perché molto
probabilmente sono quelli che avranno dei bug, quindi funzioni pure come questo per finalizzare il nostro concetto di programmazione funzionale.
Se, ad esempio, questo fosse il nostro wizard dei video precedenti con programmazione funzionale, avremmo
un oggetto wizard.
O dizionario Wizzard che aveva un nome.
Diciamo Marlon.
E potere.
Di 50.
E invece di contenerli in una classe, avrei metodi diversi come l'attacco.
E questo non sarebbe un metodo, sarebbe una funzione perché non vive all'interno di una classe.
Nella programmazione funzionale, dicono, ehi, non abbiamo bisogno di combinare dati con funzioni, teniamoli
separati, creiamo solo funzioni pure che possono essere passate a qualcosa come un carattere.
E in questo modo, teniamo queste due cose separate in modo che possiamo concentrarci sulle funzioni pure e possiamo concentrarci
sui dati, quindi è qui che sta la differenza.
Alla fine della giornata, si tratta di cercare di mantenere il nostro cappotto pulito ed evitare insetti nel nostro cappotto,
un grosso problema che i programmatori hanno sempre.
Quindi è solo un modo diverso di pensare.
Impariamo qualcosa di più nel prossimo video.