Introduktion til TypeScript-tilknyttede typer

Tilknyttede typer i TypeScript giver en måde at oprette nye typer ved at transformere eksisterende. De er et kraftfuldt værktøj til at håndtere komplekse typeoperationer og sikre typesikkerhed i TypeScript-applikationer. Denne artikel introducerer tilknyttede typer, forklarer deres syntaks og giver eksempler for at demonstrere deres brug.

Hvad er kortlagte typer?

Tilknyttede typer giver mulighed for at oprette nye typer ved at anvende en transformation til hver egenskab af en eksisterende type. De bruges ofte til at ændre eller udvide typer på en fleksibel måde. Den grundlæggende syntaks for en kortlagt type er:

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

I denne syntaks:

• T er den originale type.
• K repræsenterer hver nøgle i T.
• NewType er den nye type, der er tildelt hver egenskab.

Grundlæggende eksempel på kortlagte typer

Her er et simpelt eksempel på en tilknyttet type, der konverterer alle egenskaber af en given type til skrivebeskyttet:

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

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

type ReadOnlyUser = ReadOnly;

I dette eksempel transformerer den tilknyttede ReadOnly alle egenskaber af User-typen til at være skrivebeskyttet, hvilket resulterer i en ny type ReadOnlyUser, hvor alle egenskaber er uforanderlige.

Kortlagte Typer med Typetransformationer

Kortlagte typer kan også bruges til at transformere typer på mere komplekse måder. For eksempel en kortlagt type, der gør alle egenskaber valgfrie:

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

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

type PartialUser = Partial;

I dette eksempel gør den tilknyttede type Partial alle egenskaber af typen User valgfri, hvilket resulterer i en ny type PartialUser, hvor hver egenskab er valgfri.

Brug af tilknyttede typer med betingede typer

Kortlagte typer kan kombineres med betingede typer for mere sofistikerede typeoperationer. For eksempel oprettelse af en type, der kun indeholder egenskaber af 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 eksempel bortfiltrerer den afbildede OnlyStrings egenskaber, der ikke er af typen string, hvilket resulterer i en ny type StringProperties, der kun inkluderer strengegenskaber fra Bruger type.

Avancerede kortlagte typer

Avancerede brugstilfælde for tilknyttede typer omfatter oprettelse af typer, der ændrer eksisterende typer baseret på forskellige forhold. For eksempel en tilknyttet type, der tilføjer et suffiks til hvert egenskabsnavn:

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 eksempel tilføjer den tilknyttede type WithSuffix et suffiks til hvert egenskabsnavn af typen User, hvilket resulterer i en ny type UserWithSuffix, hvor egenskabsnavnene har de angivne suffiks.

Konklusion

Tilknyttede typer i TypeScript er en alsidig funktion, der gør det muligt for udviklere at oprette nye typer ved at transformere eksisterende. Ved at forstå og bruge kortlagte typer kan udviklere administrere komplekse typetransformationer og sikre større typesikkerhed i deres TypeScript-kode. Tilknyttede typer tilbyder kraftfulde muligheder for at forbedre og tilpasse typedefinitioner i TypeScript-applikationer.