TypeScript Academy · Leçon

Builders immuables

Retourner de nouvelles instances de Builder pour composer plus sûrement.

Builders immuables est une leçon TypeScript Academy gratuite sur CoddyKit. Ceci est la leçon 4 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.

Mutation ou immutabilité

Jusqu’ici, les constructeurs modifient this et le renvoient. Un constructeur immuable renvoie plutôt une instance nouvelle à chaque étape, sans jamais modifier l’originale. Cela rend l’assemblage plus sûr.

Le problème de la mutation partagée

Si deux parties de votre code détiennent le même constructeur mutable, l’appel d’un accesseur les affecte toutes les deux. Les constructeurs immuables évitent complètement cette surprise liée aux références partagées.

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

Renvoyer une nouvelle instance

Un accesseur immuable copie l’état actuel, ajoute le nouveau champ et construit un nouveau constructeur. L’original reste inchangé.

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

Partage structurel avec la décomposition

La décomposition { ...this.d, [k]: v } copie les entrées existantes et remplace une clé. Les valeurs inchangées sont partagées par référence, ce qui permet de conserver des copies peu coûteuses.

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

Les originaux ne changent jamais

Chaque étape produisant un nouvel objet, il est possible de créer des branches à partir d’un constructeur antérieur en toute sécurité. Vous pouvez réutiliser une base partiellement construite à plusieurs endroits.

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");

État interne readonly

Le fait de marquer les données internes comme readonly documente l’intention et empêche les écritures accidentelles sur place à l’intérieur de la classe. La seule possibilité est de créer une nouvelle instance.

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

Construction immuable typée

Le paramètre d’état est toujours transmis, ce qui nous permet de conditionner build() exactement comme précédemment, mais désormais sur une base immuable.

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

Un assemblage plus sûr

Les constructeurs immuables s’assemblent comme des valeurs : transmettez-en un, dérivez-en de nouveaux et ne craignez jamais qu’un appel en aval réécrive un état partagé. C’est le même avantage que procurent les données immuables partout ailleurs.

Préréglages réutilisables

Vous pouvez enregistrer une fois un point de départ courant et le dériver de nombreuses fois. Chaque dérivation est indépendante grâce aux accesseurs qui copient avant d’écrire.

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");

Considérations de coût

Chaque étape alloue un nouvel objet. Pour une configuration courante, ce coût est négligeable, et le partage structurel garde les copies peu profondes. Seules des boucles extrêmement sollicitées le remarqueraient.

Résumé : mutable ou immuable

Les constructeurs mutables sont légèrement plus rapides et plus simples ; les constructeurs immuables sont plus sûrs à partager et à comprendre. Préférez l’immutabilité lorsque les constructeurs sont transmis ou réutilisés comme préréglages.

Vérification rapide

Vérification rapide de cette leçon.

Récapitulatif

Un constructeur immuable renvoie une nouvelle instance à chaque étape grâce au partage structurel { ...this.d, [k]: v }, sans jamais modifier this. Les originaux restent intacts, ce qui permet un assemblage sûr et des préréglages réutilisables, pour un coût d’allocation limité.

Questions Fréquemment Posées

La leçon « Builders immuables » est-elle gratuite ?

Oui — le texte complet de « Builders immuables » 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 « Builders immuables » ?

Retourner de nouvelles instances de Builder pour composer plus sûrement. 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 4 sur 4.

Combien de temps prend la leçon « Builders immuables » ?

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