Die Generics-Muster, nach denen du greifst, gruppiert nach Aufgabe: einen Typparameter deklarieren, ihn einschränken, mit einem Standardwert versehen, mit einem bedingten Typ verzweigen, mit infer erfassen und über eine Form mappen. Jede Zeile verbindet das Muster mit einem Einzeiler-Beispiel.
Ein Generic ist ein Typparameter: ein Platzhalter für einen Typ, den der Aufrufer wählt, sodass eine Funktion oder ein Typ für viele Formen funktioniert, ohne an Präzision zu verlieren. Lies <T> als „für irgendeinen Typ T“. Die Kraft entsteht durch das Einschränken von T, das Verzweigen darauf und das Mappen darüber. Die Muster unten sind der Arbeitswortschatz.
Nachschlagetabelle · 28 Einträge
TypeScript-GenericsExplained
28 of 28 rows
Deklarieren
Ein Typparameter, den der Aufrufer wählt.
function first<T>(xs: T[]): T
Mehrere unabhängige Typparameter.
function pair<T, U>(a: T, b: U): [T, U]
Ein zweiter Parameter, an die Schlüssel des ersten gebunden.
function get<T, K extends keyof T>(o: T, k: K): T[K]
Eine Klasse mit einem Typparameter für ihre Felder und Methoden.
class Box<T> { value: T }
Eine Objektform mit einem Typparameter.
interface Result<T> { data: T }
Ein Typparameter bei einer Arrow-Function; das abschließende Komma verhindert, dass .tsx-Dateien ihn als JSX lesen.
const first = <T,>(xs: T[]): T => xs[0]
Einschränken
Verlangt, dass T zu Type zuweisbar ist.
function len<T extends { length: number }>(x: T)
Schränkt T auf einen Schlüssel eines anderen Typs ein.
type Keys<O> = keyof O
Schränkt T auf eine mit new konstruierbare Klasse ein.
function make<C extends new () => C>(c: C): C
Verlangt, dass T mehrere Constraints gleichzeitig erfüllt.
function log<T extends Error & { code: number }>(e: T)
Schränkt auf alles ein; hält den Parameter generisch, ohne ihn zu verengen.
type Wrap<T> = T extends unknown ? { v: T } : never
Standardwert & infer
Gibt T einen Standardwert, wenn der Aufrufer ihn weglässt.
function parse<T = string>(): T
Erfasst einen Typ innerhalb eines bedingten Typs.
type El<T> = T extends Array<infer I> ? I : never
Packt einen verschachtelten Promise zu seinem inneren Typ aus.
type Data = Awaited<Promise<User>>
Erfasst einen Teil eines Template-Literal-Typs.
type Path<S> = S extends `/api/${infer R}` ? R : never
Prüft die gesamte Union auf einmal; ein nacktes T inferiert Mitglied für Mitglied.
type El<T> = [T] extends [Array<infer I>] ? I : never
Bedingte und gemappte Typen
Wählt einen Typ danach, ob T zu U zuweisbar ist.
type IsStr<T> = T extends string ? true : false
Baut einen neuen Objekttyp, indem jeder Schlüssel von T transformiert wird.
type Frozen<T> = { [K in keyof T]: Readonly<T[K]> }
Ein Objekt, dessen Schlüssel K und dessen Werte V sind.
type Scores = Record<string, number>
Eingebaute Generics, aus den Mustern oben abgeleitet.
type Preview = Pick<User, "id" | "name">
Ein nacktes T vor extends läuft einmal pro Union-Mitglied und vereint die Ergebnisse.
ToArray<'a' | 'b'> = 'a'[] | 'b'[]
Fügt Modifikatoren bei gemappten Schlüsseln hinzu oder entfernt sie.
type Req<T> = { [K in keyof T]-?: T[K] }
Die Schlüssel eines Laufzeitwerts, als Typ.
const opts = { a: 1 }; type K = keyof typeof opts
Baut einen String-Typ aus anderen String-Typen.
type Route = `/users/${string}`
Verbindet Tupel-Typen Ende an Ende.
type Concat<T extends unknown[], U extends unknown[]> = [...T, ...U]
Ein Typ, dessen Definition auf sich selbst verweist.
type Json = string | number | Json[] | { [k: string]: Json }
Prüft einen Wert gegen einen Typ und behält seinen engeren Literal-Typ.
const c = { dark: "#000" } satisfies Record<string, string>
Behält den Literal-Typ des Aufrufers, statt ihn zu verbreitern (TS 5.0).