TypeScript Academy · Lezione

Funzioni pure e immutabilità

Scriva funzioni prevedibili e prive di effetti collaterali.

Funzioni pure e immutabilità è una lezione TypeScript Academy gratuita su CoddyKit. Questa è la lezione 1 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 TypeScript Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso TypeScript Academy include 4 lezioni in totale.

Che cos'è una funzione pura?

Una funzione pura restituisce lo stesso risultato a parità di input e non ha effetti collaterali. Non legge né scrive stato esterno, non modifica i propri argomenti e non esegue operazioni di I/O.

Un esempio puro

Questa funzione dipende solo dai propri argomenti e produce esclusivamente un valore restituito. Chiamarla non modifica mai nulla al di fuori di essa.

function add(a: number, b: number): number {
  return a + b;
}
console.log(add(2, 3)); // 5, always

Un esempio impuro

Questa funzione legge e modifica una variabile esterna al proprio ambito, quindi il risultato dipende da uno stato nascosto e lascia una traccia. Per questo è impura.

let counter = 0;
function next(): number {
  counter += 1; // side effect
  return counter;
}
console.log(next(), next()); // 1 2, depends on history

Trasparenza referenziale

Una chiamata pura è referenzialmente trasparente: si può sostituire la chiamata con il suo risultato senza modificare il programma. add(2, 3) può essere sostituito con 5 in qualsiasi punto.

const x = add(2, 3) * 2;
const y = 5 * 2; // identical meaning
console.log(x === y); // true

Perché la purezza è utile

Le funzioni pure sono facili da testare (non richiedono configurazione iniziale), facili da memorizzare nella cache, sicure da eseguire in parallelo e semplici da comprendere perché non hanno dipendenze nascoste.

Evitare di modificare gli argomenti

Modificare un array o un oggetto di input è un effetto collaterale che il chiamante potrebbe non aspettarsi. È preferibile costruire e restituire un nuovo valore.

// Impure: mutates input
function pushImpure(xs: number[], v: number) { xs.push(v); return xs; }
// Pure: returns a new array
function pushPure(xs: number[], v: number): number[] { return [...xs, v]; }

Aggiornamenti immutabili con spread

L'operatore spread copia un oggetto o un array, consentendo di sovrascrivere i campi senza modificare l'originale. È lo strumento principale per gli aggiornamenti immutabili in TS.

interface User { name: string; age: number }
function birthday(u: User): User {
  return { ...u, age: u.age + 1 };
}
const before = { name: "Ada", age: 30 };
const after = birthday(before);
console.log(before.age, after.age); // 30 31

Aggiornare gli array in modo immutabile

Usate map, filter e spread per derivare nuovi array invece di modificarli. L'array originale rimane intatto, così che altro codice possa continuare a utilizzarlo.

const nums = [1, 2, 3];
const doubled = nums.map(n => n * 2);
console.log(nums, doubled); // [1,2,3] [2,4,6]

readonly per maggiore sicurezza

Contrassegnare i parametri come readonly comunica al compilatore e a chi legge il codice che la funzione non li modificherà, rafforzando la purezza a livello di tipo.

function sum(xs: readonly number[]): number {
  return xs.reduce((a, b) => a + b, 0);
}
console.log(sum([1, 2, 3])); // 6

Spostare gli effetti ai margini

I programmi reali hanno bisogno di effetti, come il logging e la rete. Lo stile funzionale mantiene puro il nucleo e isola gli effetti ai confini, così la maggior parte del codice rimane prevedibile.

Una checklist mentale

Per ogni funzione chiedetevi: dipende solo dai suoi input? Restituisce soltanto un valore? Lascia invariati gli input e il mondo esterno? Tre risposte affermative significano che la funzione è pura.

Verifica rapida

Una verifica rapida su questa lezione.

Riepilogo

Le funzioni pure dipendono solo dagli input e non producono effetti collaterali, garantendo la trasparenza referenziale. Usate spread, map/filter e readonly per gli aggiornamenti immutabili, e spostate gli effetti del mondo reale ai margini del programma.

Domande Frequenti

La lezione «Funzioni pure e immutabilità» è gratuita?

Sì — il testo completo di «Funzioni pure e immutabilità» è 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 TypeScript Academy, passa a CoddyKit PRO. Il corso TypeScript Academy include 4 lezioni in totale.

Cosa imparerò in «Funzioni pure e immutabilità»?

Scriva funzioni prevedibili e prive di effetti collaterali. Eserciti TypeScript 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 TypeScript Academy?

Non è richiesta alcuna esperienza precedente. TypeScript 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 1 di 4.

Quanto tempo richiede la lezione «Funzioni pure e immutabilità»?

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 TypeScript Academy?

Sì. Ogni lezione TypeScript 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 TypeScript Academy