Was sind bedingte und abgebildete Typen?

Question

Accepted Answer

Dies sind TypeScript's **Programmiertools auf Typebene** — sie berechnen neue Typen aus bestehenden Typen. ## Abgebildete Typen — transformiere jede Eigenschaft Ein abgebildeter Typ iteriert über die Schlüssel eines Typs und transformiert jeden: ```ts type ReadonlyAll = { readonly [K in keyof T]: T[K] }; type Optional = { [K in keyof T]?: T[K] }; interface User { id: number; name: string; } type RO = ReadonlyAll; // { readonly id: number; readonly name: string } ``` `[K in keyof T]` iteriert über jeden Schlüssel `K`; `T[K]` ist der Werttyp dieses Schlüssels. So werden `Partial`, `Readonly` und `Required` implementiert. Du kannst auch Schlüssel neu abbilden und Modifikatoren hinzufügen (`-readonly`, `-?` entfernen sie). ## Bedingte Typen — verzweige je nach Bedingung ```ts type IsString = T extends string ? "yes" : "no"; type A = IsString; // "yes" type B = IsString; // "no" ``` `T extends U ? X : Y` ist ein if/else auf Typebene. Mit `infer` kannst du Typen innerhalb der Bedingung *extrahieren*: ```ts type ElementOf = T extends (infer U)[] ? U : never; type E = ElementOf; // string ``` ## Kombination — ein echtes Beispiel ```ts // Make only the function-valued properties optional type PartialMethods = { [K in keyof T]: T[K] extends Function ? T[K] | undefined : T[K]; }; ``` Abgebildete Typen **verteilen** sich auch über Unions in Bedingungen und ermöglichen so mächtige Transformationen. ## Warum es wichtig ist Abgebildete und bedingte Typen ermöglichen es Bibliotheken, präzise Typbeziehungen auszudrücken — sie implementieren Utility-Typen, stärken Formular-/Validierungsbibliotheken, ORM-Abfrage-Builder und API-Clients, die Antwortformen inferieren. Sie sind fortgeschritten, aber ihr Verständnis erklärt, *wie* TypeScript's Typensystem so ausdrucksstark sein kann, und ermöglicht es dir, wiederverwendbare Typentransformationen zu erstellen, statt Varianten von Hand zu schreiben.