Introduksjon til TypeScript-tilordnede typer

Kartlagte typer i TypeScript gir en måte å lage nye typer ved å transformere eksisterende. De er et kraftig verktøy for å håndtere komplekse typeoperasjoner og sikre typesikkerhet i TypeScript-applikasjoner. Denne artikkelen introduserer kartlagte typer, forklarer deres syntaks og gir eksempler for å demonstrere bruken.

Hva er kartlagte typer?

Kartlagte typer gjør det mulig å lage nye typer ved å bruke en transformasjon på hver egenskap av en eksisterende type. De brukes ofte til å endre eller utvide typer på en fleksibel måte. Den grunnleggende syntaksen for en kartlagt type er:

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

I denne syntaksen:

• T er originaltypen.
• K representerer hver nøkkel i T.
• NewType er den nye typen som er tilordnet hver egenskap.

Grunnleggende eksempel på kartlagte typer

Her er et enkelt eksempel på en kartlagt type som konverterer alle egenskaper for en gitt type til skrivebeskyttet:

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

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

type ReadOnlyUser = ReadOnly;

I dette eksemplet transformerer den tilordnede ReadOnly-typen alle egenskaper av User-typen til å være skrivebeskyttet, noe som resulterer i en ny type ReadOnlyUser der alle egenskaper er uforanderlige.

Kartlagte typer med typetransformasjoner

Kartlagte typer kan også brukes til å transformere typer på mer komplekse måter. For eksempel en kartlagt type som gjør alle egenskaper valgfrie:

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

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

type PartialUser = Partial;

I dette eksemplet gjør den tilordnede typen Partial alle egenskaper av typen User valgfrie, noe som resulterer i en ny type PartialUser der hver egenskap er valgfri.

Bruke tilordnede typer med betingede typer

Kartlagte typer kan kombineres med betingede typer for mer sofistikerte typeoperasjoner. For eksempel å lage en type som bare inkluderer egenskaper av en bestemt type:

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 dette eksemplet filtrerer OnlyStrings tilordnede typen ut egenskaper som ikke er av typen string, noe som resulterer i en ny type StringProperties som bare inkluderer strengegenskaper fra Bruker type.

Avanserte kartlagte typer

Avanserte brukstilfeller for kartlagte typer inkluderer å lage typer som endrer eksisterende typer basert på ulike forhold. For eksempel en tilordnet type som legger til et suffiks til hvert egenskapsnavn:

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 dette eksemplet legger den tilordnede typen WithSuffix et suffiks til hvert egenskapsnavn av typen User, noe som resulterer i en ny type UserWithSuffix der egenskapsnavnene har de spesifiserte suffiks.

Konklusjon

Kartlagte typer i TypeScript er en allsidig funksjon som gjør det mulig for utviklere å lage nye typer ved å transformere eksisterende. Ved å forstå og bruke kartlagte typer kan utviklere administrere komplekse typetransformasjoner og sikre større typesikkerhet i TypeScript-koden. Kartlagte typer tilbyr kraftige muligheter for å forbedre og tilpasse typedefinisjoner i TypeScript-applikasjoner.