TypeScript Academy · Leçon

Imposer les étapes obligatoires

Empêcher build() tant que tous les champs obligatoires ne sont pas définis.

Imposer les étapes obligatoires est une leçon TypeScript Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage TypeScript Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours TypeScript Academy comprend 4 leçons au total.

Empêcher build() trop tôt

Nous utilisons maintenant l’état accumulé pour interdire l’appel de build() tant que les champs obligatoires ne sont pas définis. C’est le système de types, et non une vérification à l’exécution, qui bloque une construction incomplète.

Définir la forme finale

Commencez par déclarer l’objet complet et les clés obligatoires. Le constructeur n’autorisera build() que lorsque l’état les contiendra toutes.

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

Signature conditionnelle de build

Nous rendons build disponible uniquement lorsque l’état accumulé S étend les clés obligatoires. Un type conditionnel renvoie la véritable méthode ou une méthode inutilisable.

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

Utiliser le paramètre this

Le paramètre this: Builder<Required> limite les instances de constructeur qui peuvent appeler build. Si S ne satisfait pas Required, l’appel constitue une erreur de type.

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

Relier les accesseurs à l’état

Chaque accesseur élargit S comme précédemment. Une fois les deux accesseurs obligatoires exécutés, S étend enfin Required et build devient appelable.

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; }
}

Le cas nominal est compilé

Lorsque les deux étapes obligatoires sont présentes, la chaîne est validée par le système de types et s’exécute. Le compilateur est certain que S inclut chaque clé obligatoire.

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

Le cas incorrect échoue

Si vous omettez une étape obligatoire, build() n’est plus validé par le système de types, car le S du constructeur n’étend pas Required. L’erreur est détectée lors de la compilation.

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

Pourquoi cette approche surpasse les protections à l’exécution

Un if (!this.url) throw à l’exécution n’échoue que lorsque le code s’exécute. L’approche fondée sur le paramètre this échoue lors de la vérification des types ; les constructions incomplètes ne sont donc jamais livrées.

Les champs facultatifs restent facultatifs

Les étapes facultatives comme timeout ne font jamais partie de Required ; elles ne conditionnent donc pas build(). Vous pouvez les inclure ou les ignorer librement.

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

Gérer de nombreuses exigences

Ajoutez d’autres clés obligatoires à la forme Required et au paramètre this ; le compilateur les imposera toutes. Ce modèle s’adapte à n’importe quel nombre d’étapes obligatoires.

Limitations

La garantie dépend du fait de transmettre honnêtement S à travers chaque accesseur et d’utiliser le typage du paramètre this. Les conversions doivent rester confinées aux accesseurs afin que les appelants bénéficient d’une sécurité complète du typage.

Vérification rapide

Vérification rapide de cette leçon.

Récapitulatif

Pour imposer les étapes obligatoires, typiez build avec un paramètre this: Builder<Required>. La méthode n’est validée par le système de types que lorsque l’état accumulé S inclut chaque clé obligatoire, transformant ainsi une construction incomplète en erreur de compilation.

Questions Fréquemment Posées

La leçon « Imposer les étapes obligatoires » est-elle gratuite ?

Oui — le texte complet de « Imposer les étapes obligatoires » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours TypeScript Academy, passe à CoddyKit PRO. Le cours TypeScript Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Imposer les étapes obligatoires » ?

Empêcher build() tant que tous les champs obligatoires ne sont pas définis. Tu pratiques TypeScript Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer TypeScript Academy ?

Aucune expérience préalable n'est requise. TypeScript Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Imposer les étapes obligatoires » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon TypeScript Academy ?

Oui. Chaque leçon TypeScript Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à TypeScript Academy