Stark typisierte Builder
Entwerfen Sie verkettbare Builder, die typisierte Optionen schrittweise aufbauen, und stellen Sie mit Generics und bedingten Typen erforderliche Schritte und gültige Kombinationen sicher.
Stark typisierte Builder ist eine kostenlose TypeScript Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 3. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des TypeScript Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der TypeScript Academy-Kurs umfasst insgesamt 3 Lektionen.
Einführung
Ziel: Erstellen Sie verkettbare APIs, die den Fortschritt im Typ abbilden. Jeder Schritt gibt einen neuen typisierten Zustand zurück, sodass ungültige Reihenfolgen bei der Kompilierung fehlschlagen.
- Optionen in einem Generic sammeln
- Schritte mit Flags steuern
- Die DX einfach halten
Status-Flags
Jeder Schritt gibt einen neuen Zustandstyp zurück; build ist nur zugänglich, wenn die erforderlichen Flags true sind.
type Flags = { method: boolean; url: boolean }
type With<F extends Partial<Flags>> = { flags: F }
type True = true
type Builder<F extends Partial<Flags>, O extends Record<string, unknown>> = With<F> & {
method<M extends "GET" | "POST">(m: M): Builder<F & { method: True }, O & { method: M }>
url<U extends `/${string}`>(u: U): Builder<F & { url: True }, O & { url: U }>
build(this: Builder<{ method: True; url: True }, any>): O
}
function createBuilder(): Builder<{}, {}> {
return {
flags: {},
method(m) { return { ...this, flags: { ...this.flags, method: true }, method: this.method, url: this.url, build: this.build } as any },
url(u) { return { ...this, flags: { ...this.flags, url: true }, method: this.method, url: this.url, build: this.build } as any },
build() { return this as any }
} as any
}
const b = createBuilder()
const good = b.method("GET").url("/users").build() // ok
// const bad = b.build() // error: build requires method & url flagsOptionen sammeln
Sammeln Sie Optionen im Generic O; jeder Aufruf gibt einen Typ zurück, der neue Eigenschaften hinzufügt.
type B2<F extends Partial<Flags>, O extends Record<string, unknown>> = With<F> & {
header<K extends string, V extends string>(k: K, v: V): B2<F, O & { headers: Record<K, V> }>
query<K extends string, V extends string>(k: K, v: V): B2<F, O & { query: Record<K, V> }>
method<M extends "GET" | "POST">(m: M): B2<F & { method: True }, O & { method: M }>
url<U extends `/${string}`>(u: U): B2<F & { url: True }, O & { url: U }>
build(this: B2<{ method: True; url: True }, any>): O
}
function builder2(): B2<{}, {}> { return {} as any }
const conf = builder2()
.method("POST")
.url("/login")
.header("x-id", "42")
.query("next", "home")
.build()Gültige Kombinationen
Beschränken Sie Kombinationen mit bedingten Typen: Erlauben Sie den Body nur bei POST.
type Method = "GET" | "POST"
type BodyIfPost<M extends Method, B> = M extends "POST" ? { body: B } : {}
type B3<F extends Partial<Flags>, O extends Record<string, unknown>> = With<F> & {
method<M extends Method>(m: M): B3<F & { method: True }, O & { method: M }>
url<U extends `/${string}`>(u: U): B3<F & { url: True }, O & { url: U }>
body<B>(b: B & (O extends { method: "POST" } ? unknown : never)): B3<F, O & BodyIfPost<O extends { method: infer M } ? Extract<M, Method> : Method, B>>
build(this: B3<{ method: True; url: True }, any>): O
}
function builder3(): B3<{}, {}> { return {} as any }
const ok = builder3().method("POST").url("/u").body({ a: 1 }).build()
// const badBody = builder3().method("GET").url("/u").body({ a: 1 }).build() // compile-time errorVariadische Pipeline
Sammeln Sie Schritte mit einem Array aus variadischen Tupeln; verwalten Sie Ein- und Ausgaben mit Parameters/ReturnType.
type Step<A extends any[], R> = (...args: A) => R
type Pipeline<P extends Step<any, any>[]> = {
use<S extends Step<any, any>>(...s: [S]): Pipeline<[...P, S]>
run<A extends Parameters<P[0]>>(this: Pipeline<P>, ...args: A): ReturnType<P[number]>
}
function pipeMake(): Pipeline<[]> { return {} as any }
const pipe = pipeMake()
.use((a: string) => a.length)
.use((n: number) => n % 2 === 0)
// pipe.run("abc") // demo; implementation omittedTipps
Tipps:
Halten Sie den Status als Phantom-Generic; belasten Sie damit nicht die Laufzeit.
Halten Sie Schrittnamen kurz und fest (method, url).
Trennen Sie schwierige Kombinationen mit bedingten Typen und halten Sie die Kette übersichtlich.
Builder-Steuerung prüfen
Schnelltest: Wie stellen wir sicher, dass .method() vor .build() aufgerufen wird?
Zusammenfassung
Zusammenfassung: Führen Sie typisierten Zustand durch die Kette, sammeln Sie Optionen in Generics und erkennen Sie ungültige Sequenzen bei der Kompilierung.
Häufig gestellte Fragen
Ist die Lektion „Stark typisierte Builder“ kostenlos?
Ja — der vollständige Text von „Stark typisierte Builder“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des TypeScript Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der TypeScript Academy-Kurs umfasst insgesamt 3 Lektionen.
Was lerne ich in „Stark typisierte Builder“?
Entwerfen Sie verkettbare Builder, die typisierte Optionen schrittweise aufbauen, und stellen Sie mit Generics und bedingten Typen erforderliche Schritte und gültige Kombinationen sicher. Du übst TypeScript Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um TypeScript Academy zu starten?
Keine Vorkenntnisse erforderlich. TypeScript Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 3.
Wie lange dauert die Lektion „Stark typisierte Builder“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser TypeScript Academy-Lektion Code schreiben und ausführen?
Ja. Jede TypeScript Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Rest-Elemente in Tupeln, Curry-Typen
- Funktionen und Argumente sicher kombinieren
- Stark typisierte Builder