TypeScript Academy · Lezione

Basi del Builder Pattern

Costruisca oggetti complessi passo dopo passo.

Basi del Builder Pattern è 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.

Perché utilizzare un Builder?

Alcuni oggetti richiedono molti campi e costruirli con un costruttore enorme, pieno di argomenti posizionali, è soggetto a errori. Il Builder pattern costruisce un oggetto complesso passo dopo passo, con una chiamata nominata alla volta.

L'oggetto desiderato

Immagini una richiesta HTTP con un url, un metodo, gli header e un body. Passare tutti questi elementi a un unico costruttore è difficile da leggere. Un builder consente di impostare ogni parte con un metodo dal nome esplicito.

interface HttpRequest {
  url: string;
  method: string;
  headers: Record<string, string>;
  body?: string;
}

Una classe Builder di base

Il builder conserva internamente uno stato parziale ed espone metodi setter. Ogni setter modifica lo stato interno ed è responsabile di un singolo campo.

class RequestBuilder {
  private url = "";
  private method = "GET";
  private headers: Record<string, string> = {};
  private body?: string;
}

Il concatenamento dei metodi restituisce this

Il meccanismo che rende fluida la lettura dei builder consiste nel restituire this da ogni setter. Poiché ogni metodo restituisce lo stesso builder, è possibile concatenare le chiamate.

class RequestBuilder {
  private url = "";
  setUrl(u: string): this {
    this.url = u;
    return this;
  }
}

Aggiungere altri passaggi

Ogni passaggio di configurazione segue lo stesso schema: memorizzare il valore e poi restituire this. Noti che il tipo restituito this mantiene il tipo concreto del builder lungo tutta la catena.

  setMethod(m: string): this {
    this.method = m;
    return this;
  }
  addHeader(k: string, v: string): this {
    this.headers[k] = v;
    return this;
  }

Il metodo build()

Infine, un metodo build() assembla lo stato accumulato nell'oggetto completo. È l'unico metodo che non restituisce il builder.

  build(): HttpRequest {
    return {
      url: this.url,
      method: this.method,
      headers: this.headers,
      body: this.body,
    };
  }

Utilizzare il Builder

A questo punto la costruzione si legge come una frase. Ogni passaggio ha un nome, l'ordine è flessibile e non è più necessario gestire argomenti posizionali.

const req = new RequestBuilder()
  .setUrl("https://api.test")
  .setMethod("POST")
  .addHeader("Accept", "application/json")
  .build();
console.log(req.method);

Un esempio completo eseguibile

Ecco una versione autonoma che può eseguire. Il builder accumula lo stato e build() produce l'oggetto finale, apparentemente immutabile.

interface Req { url: string; method: string }
class B {
  private url = ""; private method = "GET";
  setUrl(u: string): this { this.url = u; return this; }
  setMethod(m: string): this { this.method = m; return this; }
  build(): Req { return { url: this.url, method: this.method }; }
}
const r = new B().setUrl("/users").setMethod("POST").build();
console.log(r.url, r.method);

I valori predefiniti sono inclusi

Poiché il builder inizializza i campi con valori predefiniti sensati, chi lo utilizza deve sovrascrivere solo ciò che serve. I passaggi non impostati mantengono semplicemente i valori predefiniti.

const getReq = new B().setUrl("/health").build();
console.log(getReq.method); // GET (default)

Leggibilità a confronto con i costruttori

Confronti new Req("/x", "POST", {}, undefined) con il builder concatenato. La versione con il builder documenta l'intento a ogni passaggio ed evita i segnaposto undefined dal significato poco chiaro.

Quando sceglierlo

Utilizzi un builder quando un oggetto ha molte parti opzionali, quando la costruzione avviene per passaggi o quando desidera un'API leggibile e autoesplicativa. Per due o tre campi, un semplice object literal è più pratico.

Verifica rapida

Una verifica rapida su questa lezione.

Riepilogo

Un builder costruisce oggetti complessi passo dopo passo. I setter memorizzano un campo ciascuno e restituiscono this per consentire il concatenamento, mentre build() assembla l'oggetto finale. I builder sono particolarmente utili quando gli oggetti hanno molte parti facoltative.

Domande Frequenti

La lezione «Basi del Builder Pattern» è gratuita?

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

Costruisca oggetti complessi passo dopo passo. 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 «Basi del Builder Pattern»?

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