TypeScript Academy · Lezione

Builder immutabili

Restituisca nuove istanze del builder per una composizione più sicura.

Builder immutabili è una lezione TypeScript Academy gratuita su CoddyKit. Questa è la lezione 4 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.

Mutabilità e immutabilità

I builder esaminati finora modificano this e lo restituiscono. Un builder immutabile, invece, restituisce una nuova istanza di builder a ogni passaggio, senza modificare mai quella originale. Questo rende la composizione più sicura.

Il problema della mutazione condivisa

Se due parti del codice hanno lo stesso builder mutabile, una chiamata a un setter ha effetto su entrambe. I builder immutabili evitano completamente questa sorpresa dovuta alla condivisione dei riferimenti.

const base = makeMutableBuilder().url("/x");
// If base is shared, later .method() calls mutate everyone's copy.

Restituire una nuova istanza

Un setter immutabile copia lo stato corrente, aggiunge il nuovo campo e costruisce un builder nuovo. L'originale non viene modificato.

class IB<S> {
  constructor(private readonly d: Record<string, unknown> = {}) {}
  with<K extends string, V>(k: K, v: V): IB<S & Record<K, V>> {
    return new IB<S & Record<K, V>>({ ...this.d, [k]: v });
  }
}

Condivisione strutturale con spread

Lo spread { ...this.d, [k]: v } copia le voci esistenti e sovrascrive una chiave. I valori invariati vengono condivisi per riferimento, quindi le copie rimangono poco costose.

const a = new IB<{}>().with("url", "/x");
const c = a.with("method", "GET");
// a still only has url; c has url and method.

Gli originali non cambiano mai

Poiché ogni passaggio produce un nuovo oggetto, è sicuro creare diramazioni a partire da un builder precedente. È possibile riutilizzare una base parzialmente costruita in più punti.

const base = new IB<{}>().with("url", "/api");
const get = base.with("method", "GET");
const post = base.with("method", "POST");
console.log("base untouched; get and post diverge");

Stato interno readonly

Contrassegnare i dati interni come readonly documenta l'intento e impedisce scritture accidentali direttamente nell'istanza all'interno della classe. L'unico modo per procedere è creare una nuova istanza.

class IB<S> {
  constructor(private readonly d: Readonly<Record<string, unknown>> = {}) {}
}

Build immutabile tipizzata

Il parametro di stato continua a essere propagato, quindi possiamo condizionare build() esattamente come prima, ora su una base immutabile.

interface Out { url: string; method: string }
class IB<S> {
  constructor(private readonly d: Record<string, unknown> = {}) {}
  with<K extends string, V>(k: K, v: V): IB<S & Record<K, V>> {
    return new IB<S & Record<K, V>>({ ...this.d, [k]: v });
  }
  build(this: IB<{ url: string; method: string }>): Out { return this.d as Out; }
}
const out = new IB<{}>().with("url", "/u").with("method", "GET").build();
console.log(out.url);

Composizione più sicura

I builder immutabili si combinano come valori: se ne passa uno ad altre parti del codice, se ne derivano di nuovi e non ci si deve mai preoccupare che una chiamata successiva riscriva lo stato condiviso. È lo stesso vantaggio offerto dai dati immutabili in generale.

Preset riutilizzabili

È possibile salvare una volta sola un punto di partenza comune e crearne molte diramazioni. Ogni diramazione è indipendente grazie ai setter copy-on-write.

const jsonBase = new IB<{}>().with("header", "application/json");
const usersReq = jsonBase.with("url", "/users");
const ordersReq = jsonBase.with("url", "/orders");
console.log("two independent requests from one base");

Considerazioni sui costi

A ogni passaggio viene allocato un nuovo oggetto. Per la normale costruzione di configurazioni, il costo è trascurabile e la condivisione strutturale mantiene le copie superficiali. Solo cicli estremamente frequenti se ne accorgerebbero.

Riepilogo: mutabile e immutabile

I builder mutabili sono leggermente più veloci e semplici; quelli immutabili sono più sicuri da condividere e da analizzare. Preferite l'immutabilità quando i builder vengono passati ad altre parti del codice o riutilizzati come preset.

Verifica rapida

Una verifica rapida su questa lezione.

Riepilogo

Un builder immutabile restituisce una nuova istanza a ogni passaggio usando la condivisione strutturale { ...this.d, [k]: v }, senza modificare mai this. Gli originali rimangono intatti, consentendo una composizione sicura e preset riutilizzabili, con un costo di allocazione contenuto.

Domande Frequenti

La lezione «Builder immutabili» è gratuita?

Sì — il testo completo di «Builder immutabili» è 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 «Builder immutabili»?

Restituisca nuove istanze del builder per una composizione più sicura. 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 4 di 4.

Quanto tempo richiede la lezione «Builder immutabili»?

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