Betingede typer

Betingede typer i TypeScript giver dig mulighed for at oprette typer, der tilpasser sig dynamisk baseret på en betingelse, så din kode bliver mere fleksibel og genanvendelig.

De bruger en syntaks, der ligner JavaScripts betingelsesoperator (ternary).

Betingede typer giver dig mulighed for at definere en type, der afhænger af en anden type. Grundsyntaksen er:

T extends U ? X : Y

Det betyder: Hvis T udvider U, er typen X, ellers er den Y.

Her er et enkelt eksempel:

type IsString<T> = T extends string ? 'Yes' : 'No';

// Test cases
type A = IsString<string>; // 'Yes'
type B = IsString<number>; // 'No'

Betingede typer kan forenkle funktionsoverbelastning ved dynamisk at bestemme returtyper:

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

function getData(): string {
  return 'Hello';
}

type DataType = ReturnType<typeof getData>; // string

Når betingede typer anvendes på unionstyper, fordeles de på hvert medlem af unionen:

type ToArray<T> = T extends any ? T[] : never;

type A = ToArray<string | number>;
// A = string[] | number[]

Du kan kombinere betingede typer med afbildede typer for at skabe kraftfulde typeomdannelser:

type User = {
  id: number;
  name: string;
  isAdmin?: boolean;
};

type MakeRequired<T> = {
  [K in keyof T]-?: T[K] extends undefined ? never : T[K];
};

type RequiredUser = MakeRequired<User>;
// { id: number; name: string; isAdmin: never; }

Betingede typer bruges typisk til:

• At udlede returtyper eller parametre.
• At omdanne unioner og snit.
• At oprette hjælpe-typer som Exclude, Extract og NonNullable.

Opret en betinget type, der undersøger, om en type er et array, og som i så fald returnerer dens elementtype; ellers returnerer den selve typen.

Du har lært at bruge betingede typer til at oprette dynamiske og genanvendelige typedefinitioner i TypeScript. Øv dig i disse begreber for at skrive mere effektiv og fleksibel TypeScript-kode!