Introduktion till TypeScript mappade typer

Mappade typer i TypeScript ger ett sätt att skapa nya typer genom att transformera befintliga. De är ett kraftfullt verktyg för att hantera komplexa typoperationer och säkerställa typsäkerhet i TypeScript-applikationer. Den här artikeln introducerar mappade typer, förklarar deras syntax och ger exempel för att visa hur de används.

Vad är kartlagda typer?

Mappade typer gör det möjligt att skapa nya typer genom att tillämpa en transformation på varje egenskap av en befintlig typ. De används ofta för att modifiera eller utöka typer på ett flexibelt sätt. Den grundläggande syntaxen för en mappad typ är:

type MappedType = {
  [K in keyof T]: NewType;
};

I denna syntax:

• T är originaltypen.
• K representerar varje nyckel i T.
• NewType är den nya typen som tilldelas varje egenskap.

Grundläggande exempel på mappade typer

Här är ett enkelt exempel på en mappad typ som konverterar alla egenskaper av en given typ till skrivskyddad:

type ReadOnly = {
  readonly [K in keyof T]: T[K];
};

type User = {
  name: string;
  age: number;
};

type ReadOnlyUser = ReadOnly;

I det här exemplet omvandlar den mappade typen ReadOnly alla egenskaper av typen User till att vara skrivskyddade, vilket resulterar i en ny typ ReadOnlyUser där alla egenskaper är oföränderliga.

Kartlagda typer med typtransformationer

Kartlagda typer kan också användas för att transformera typer på mer komplexa sätt. Till exempel en mappad typ som gör alla egenskaper valfria:

type Partial = {
  [K in keyof T]?: T[K];
};

type User = {
  name: string;
  age: number;
};

type PartialUser = Partial;

I det här exemplet gör den mappade typen Partial alla egenskaper av typen User valfria, vilket resulterar i en ny typ PartialUser där varje egenskap är valfri.

Använda mappade typer med villkorliga typer

Kartlagda typer kan kombineras med villkorade typer för mer sofistikerade typoperationer. Till exempel skapa en typ som bara innehåller egenskaper av en viss typ:

type OnlyStrings = {
  [K in keyof T]: T[K] extends string ? T[K] : never;
};

type User = {
  name: string;
  age: number;
  email: string;
};

type StringProperties = OnlyStrings;

I det här exemplet filtrerar den mappade typen OnlyStrings bort egenskaper som inte är av typen string, vilket resulterar i en ny typ StringProperties som endast inkluderar strängegenskaper från Användare typ.

Avancerade mappade typer

Avancerade användningsfall för mappade typer inkluderar att skapa typer som modifierar befintliga typer baserat på olika villkor. Till exempel en mappad typ som lägger till ett suffix till varje egenskapsnamn:

type WithSuffix<T, S extends string> = {
  [K in keyof T as `${string & K}${S}`]: T[K];
};

type User = {
  name: string;
  age: number;
};

type UserWithSuffix = WithSuffix<User, "Prop">;

I det här exemplet lägger den mappade typen WithSuffix till ett suffix till varje egenskapsnamn av typen User, vilket resulterar i en ny typ UserWithSuffix där egenskapsnamnen har det angivna ändelse.

Slutsats

Mappade typer i TypeScript är en mångsidig funktion som gör det möjligt för utvecklare att skapa nya typer genom att omvandla befintliga. Genom att förstå och använda mappade typer kan utvecklare hantera komplexa typtransformationer och säkerställa större typsäkerhet i sin TypeScript-kod. Mappade typer erbjuder kraftfulla funktioner för att förbättra och anpassa typdefinitioner i TypeScript-applikationer.