Oföränderliga builders
Returnera nya builder-instanser för säkrare komposition.
Oföränderliga builders är en gratis lektion i TypeScript Academy på CoddyKit. Detta är lektion 4 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för TypeScript Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i TypeScript Academy innehåller totalt 4 lektioner.
Muterbarhet kontra oföränderlighet
Hittills har builders ändrat this och returnerat det. En oföränderlig builder returnerar i stället en ny builder-instans vid varje steg utan att någonsin ändra originalet. Det gör komposition säkrare.
Problemet med delad mutering
Om två delar av koden har samma föränderliga builder påverkar ett setter-anrop båda delarna. Oföränderliga builders undviker helt denna överraskning med aliasing.
const base = makeMutableBuilder().url("/x");
// If base is shared, later .method() calls mutate everyone's copy.Returnera en ny instans
En setter-metod i en oföränderlig builder kopierar det aktuella tillståndet, lägger till det nya fältet och skapar en ny builder. Originalet förblir orört.
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 });
}
}Strukturell delning med spread
Spread-uttrycket { ...this.d, [k]: v } kopierar befintliga poster och skriver över en nyckel. Oförändrade värden delas genom referenser, så kopiorna förblir billiga.
const a = new IB<{}>().with("url", "/x");
const c = a.with("method", "GET");
// a still only has url; c has url and method.Originalen ändras aldrig
Eftersom varje steg ger ett nytt objekt är det säkert att skapa grenar från en tidigare builder. Du kan återanvända en delvis byggd grund på flera ställen.
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");Readonly internt tillstånd
Att markera interna data som readonly dokumenterar avsikten och förhindrar oavsiktliga ändringar på plats inuti klassen. Det enda sättet att gå vidare är att skapa en ny instans.
class IB<S> {
constructor(private readonly d: Readonly<Record<string, unknown>> = {}) {}
}Typad oföränderlig build
Tillståndsparametern förs fortfarande vidare, så vi kan begränsa build() på exakt samma sätt som tidigare, nu på en oföränderlig grund.
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);Säkrare komposition
Oföränderliga builders kan komponeras som värden: skicka runt en, härled nya och oroa dig aldrig för att ett senare anrop skriver om delat tillstånd. Det är samma fördel som oföränderliga data ger överallt.
Återanvändbara förinställningar
Du kan spara en vanlig startpunkt en gång och skapa många grenar från den. Varje gren är oberoende tack vare setter-metoderna med kopiering vid skrivning.
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");Kostnadsaspekter
Varje steg allokerar ett nytt objekt. För typisk konfigurationsuppbyggnad är detta försumbart, och strukturell delning håller kopiorna ytliga. Endast extremt heta loopar skulle märka skillnaden.
Sammanfattning av muterbar och oföränderlig
Muterbara builders är något snabbare och enklare, medan oföränderliga builders är säkrare att dela och resonera kring. Föredra oföränderliga builders när de skickas runt eller återanvänds som förinställningar.
Kort kontroll
En kort kontroll av den här lektionen.
Sammanfattning
En oföränderlig builder returnerar en ny instans per steg med strukturell delning via { ...this.d, [k]: v } och ändrar aldrig this. Originalen förblir intakta, vilket möjliggör säker komposition och återanvändbara förinställningar, med endast en mindre kostnad för allokeringar.
Lär dig TypeScript med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 101
- Lektioner
- 352
Vanliga frågor
Är lektionen ”Oföränderliga builders” gratis?
Ja – hela texten till ”Oföränderliga builders” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i TypeScript Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i TypeScript Academy innehåller totalt 4 lektioner.
Vad lär jag mig i ”Oföränderliga builders”?
Returnera nya builder-instanser för säkrare komposition. Ni övar på TypeScript Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig TypeScript Academy?
Du behöver inga förkunskaper. Utbildningen i TypeScript Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.
Hur lång tid tar lektionen ”Oföränderliga builders”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här TypeScript Academy-lektionen?
Ja. Varje TypeScript Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Grunderna i Builder Pattern
- Fluent interfaces med typer
- Säkerställ obligatoriska steg
- Oföränderliga builders