Disse er TypeScript's programmeringsværktøjer på typeniveau — de beregner nye typer ud fra eksisterende typer.
En mappedet type itererer over nøglerne for en type og transformerer hver enkelt:
<T> = { [K keyof T]: T[K] };
<T> = { [K keyof T]?: T[K] };
{ : ; : ; }
= <>;
[K in keyof T] løkker over hver nøgle K; T[K] er den nøgles værditype. Dette er hvordan Partial, Readonly og Required implementeres. Du kan også remappes nøgler og tilføje modifikatorer (-readonly, -? fjerner dem).
type IsString<T> = T extends string ? "yes" : "no";
type A = IsString<string>; // "yes"
type B = IsString<number>; // "no"
T extends U ? X : Y er en if/else på typeniveau. Med infer kan du udtrække typer inden i betingelsen:
type ElementOf<T> = T extends (infer U)[] ? U : never;
type E = ElementOf<string[]>; // string
// Make only the function-valued properties optional
type PartialMethods<T> = {
[K in keyof T]: T[K] extends Function ? T[K] | undefined : T[K];
};
Mappede typer distribuerer også over unions i betingelser, hvilket muliggør kraftfulde transformationer.
Mappede og betingede typer lader biblioteker udtrykke præcise typeforhold — de implementerer utility-typer, styrker formular-/valideringsbiblioteker, ORM-forespørgselsbyggere og API-klienter, der slutleder svararketyper.
De er avancerede, men at forstå dem forklarer hvordan TypeScript's typesystem kan være så udtryksfuldt, og lader dig bygge genanvendelige typetransformationer i stedet for at skrive varianter for hånd.