TypeScript villkorliga typer

Villkorstyper i TypeScript ger ett sätt att skapa typer som är beroende av ett villkor. De möjliggör större flexibilitet och uttrycksfullhet i typdefinitioner, vilket gör det möjligt att modellera komplexa typrelationer på ett tydligt och kortfattat sätt. Den här artikeln utforskar hur villkorliga typer fungerar i TypeScript och ger exempel för att illustrera deras användning.

Vad är villkorliga typer?

Villkorstyper möjliggör skapandet av typer som väljs baserat på ett villkor. De liknar villkorliga uttalanden i programmering men fungerar på typnivå. Den grundläggande syntaxen för en villkorlig typ är:

type ConditionalType = T extends U ? X : Y;

I denna syntax:

• T är typen som kontrolleras.
• U är typen att jämföra mot.
• X är typen som returneras om T förlänger U.
• Y är typen som returneras om T inte förlänger U.

Grundläggande exempel på villkorliga typer

Här är ett enkelt exempel på en villkorlig typ som returnerar olika typer baserat på om en given typ är en sträng eller inte:

type IsString = T extends string ? "String" : "Not a string";

type Result1 = IsString;  // Result1 is "String"
type Result2 = IsString;  // Result2 is "Not a string"

I det här exemplet kontrollerar IsString om T förlänger sträng. Om den gör det blir resultatet "String"; annars är det "Not a string".

Använda villkorliga typer med generiska typer

Villkorliga typer kan också användas med generiska typer för att skapa mer flexibla och återanvändbara typdefinitioner. Till exempel, en typ som extraherar returtypen för en funktion:

type ReturnType = T extends (...args: any[]) => infer R ? R : never;

type FunctionType = (x: number) => string;

type Result = ReturnType;  // Result is string

I det här exemplet använder ReturnType nyckelordet infer för att sluta sig till returtypen R för funktionstypen T. Om T är en funktionstyp, kommer ReturnType att vara returtypen; annars är den standard till aldrig.

Villkorliga typer med fackliga typer

Villkorstyper kan också fungera med fackföreningstyper för att hantera flera möjliga typer. Till exempel att skilja mellan olika fackmedlemmar:

type ExtractString = T extends string ? T : never;

type UnionType = string | number | boolean;

type Result = ExtractString;  // Result is string

I det här exemplet extraherar ExtractStringstring från en unionstyp UnionType, vilket resulterar i sträng.

Villkorstyper med typmappningar

Villkorstyper kan kombineras med typmappningar för att skapa mer komplexa typtransformationer. Till exempel, mappa över en array av typer för att tillämpa en villkorlig typ:

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

type ArrayType = [string, number, boolean];

type MappedArray = MapArray;  // MappedArray is [string, never, never]

I det här exemplet mappar MapArray varje element i arrayen T och tillämpar en villkorlig typ på varje element, vilket resulterar i en array där endast strängelement bevaras.

Slutsats

Villkorstyper i TypeScript är ett kraftfullt verktyg för att skapa flexibla och uttrycksfulla typdefinitioner. Genom att utnyttja villkorstyper kan utvecklare modellera komplexa typrelationer, hantera olika scenarier och förbättra typsäkerheten i sin TypeScript-kod. Att förstå hur man använder villkorliga typer effektivt kan avsevärt förbättra förmågan att skriva robust och underhållbar TypeScript-kod.