Dessa är TypeScript:s typnivå-programmeringsverktyg — de beräknar nya typer från befintliga.
En mappad typ itererar över nycklarna i en typ och transformerar var och en:
<T> = { [K keyof T]: T[K] };
<T> = { [K keyof T]?: T[K] };
{ : ; : ; }
= <>;
[K in keyof T] loopar över varje nyckel K; T[K] är den nyckelns värdetyp. Detta är hur Partial, Readonly och Required är implementerade. Du kan också omappar nycklar och lägga till modifierare (-readonly, -? tar bort dem).
type IsString<T> = T extends string ? "yes" : "no";
type A = IsString<string>; // "yes"
type B = IsString<number>; // "no"
T extends U ? X : Y är en typnivå if/else. Med infer kan du extrahera typer inuti villkoret:
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];
};
Mappade typer distribuerar också över unions i villkor, vilket möjliggör kraftfulla transformationer.
Mappade och villkorliga typer låter bibliotek uttrycka exakta typrelationer — de implementerar utility-typerna, driver form/validering-bibliotek, ORM-frågebyggare och API-klienter som härleder svarsformer.
De är avancerade, men att förstå dem förklarar hur TypeScript:s typsystem kan vara så uttrycksfullt, och låter dig bygga återanvändbara typomvandlingar istället för att hand-skriva varianter.