TypeScript Academy · Lezione

Imporre i passaggi obbligatori

Impedisca build() finché tutti i campi obbligatori non sono impostati.

Imporre i passaggi obbligatori è una lezione TypeScript Academy gratuita su CoddyKit. Questa è la lezione 3 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.

Impedire build() prima del tempo

Ora usiamo lo stato accumulato per impedire la chiamata a build() finché non sono stati impostati i campi obbligatori. È il sistema dei tipi, non un controllo a runtime, a bloccare una build incompleta.

Definire la struttura finale

Iniziate dichiarando l'oggetto completo e le chiavi obbligatorie. Il builder permetterà build() solo quando lo stato le conterrà tutte.

interface Config {
  url: string;   // required
  method: string; // required
  timeout?: number; // optional
}
type Required = { url: string; method: string };

Firma condizionale di build

Rendiamo build disponibile solo quando lo stato accumulato S estende le chiavi obbligatorie. Un tipo condizionale restituisce il metodo reale oppure uno inutilizzabile.

class Builder<S> {
  build(this: Builder<Required>): Config {
    return this.d as Config;
  }
  private d: Record<string, unknown> = {};
}

Usare il parametro this

Il parametro this: Builder<Required> limita quali istanze di builder possono chiamare build. Se S non soddisfa Required, la chiamata produce un errore di tipo.

// Only a Builder whose S includes url and method
// can legally invoke build().

Collegare i setter allo stato

Ogni setter amplia S come prima. Dopo l'esecuzione di entrambi i setter obbligatori, S estende finalmente Required e build diventa chiamabile.

class Builder<S> {
  private d: Record<string, unknown> = {};
  url(u: string): Builder<S & { url: string }> { this.d.url = u; return this as any; }
  method(m: string): Builder<S & { method: string }> { this.d.method = m; return this as any; }
  build(this: Builder<{ url: string; method: string }>): Config { return this.d as Config; }
}

Il percorso corretto compila

Quando sono presenti entrambi i passaggi obbligatori, la catena viene verificata correttamente e può essere eseguita. Il compilatore ha la certezza che S includa ogni chiave obbligatoria.

const cfg = new Builder<{}>().url("/x").method("GET").build();
console.log(cfg.url, cfg.method);

Il percorso errato fallisce

Se si omette un passaggio obbligatorio, build() non supera più il controllo dei tipi, perché S del builder non estende Required. L'errore viene rilevato in fase di compilazione.

// const bad = new Builder<{}>().url("/x").build();
// Error: 'build' can only be called when method is set too.

Perché è meglio dei controlli a runtime

Un controllo a runtime come if (!this.url) throw fallisce solo quando il codice viene eseguito. L'approccio con il parametro this fallisce durante il controllo dei tipi, quindi le build incomplete non arrivano mai in produzione.

I campi facoltativi restano tali

I passaggi facoltativi come timeout non fanno mai parte di Required, quindi non condizionano build(). È possibile includerli o ometterli liberamente.

const ok = new Builder<{}>().method("PUT").url("/y").build();
console.log("order of required steps does not matter");

Scalare a molti requisiti

Aggiungete altre chiavi obbligatorie alla struttura Required e al parametro this: il compilatore le farà rispettare tutte. Il modello si adatta a un numero qualsiasi di passaggi obbligatori.

Limitazioni

La garanzia dipende dal propagare correttamente S attraverso ogni setter e dall'usare la tipizzazione del parametro this. I cast devono essere confinati nei setter, così chi li utilizza rimane completamente protetto dal sistema dei tipi.

Verifica rapida

Una verifica rapida su questa lezione.

Riepilogo

Per imporre i passaggi obbligatori, tipizzate build con un parametro this: Builder<Required>. Il metodo supera il controllo dei tipi solo quando lo stato accumulato S include ogni chiave obbligatoria, trasformando la costruzione incompleta in un errore di compilazione.

Domande Frequenti

La lezione «Imporre i passaggi obbligatori» è gratuita?

Sì — il testo completo di «Imporre i passaggi obbligatori» è 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 «Imporre i passaggi obbligatori»?

Impedisca build() finché tutti i campi obbligatori non sono impostati. 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 3 di 4.

Quanto tempo richiede la lezione «Imporre i passaggi obbligatori»?

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