Conditionele typen

Met voorwaardelijke typen in TypeScript kun je typen maken die zich dynamisch aanpassen op basis van een voorwaarde, waardoor je code flexibeler en herbruikbaarder wordt.

Ze gebruiken een syntaxis die vergelijkbaar is met die van de voorwaardelijke (ternary)-operator van JavaScript.

Met voorwaardelijke typen kun je een type definiëren dat afhankelijk is van een ander type. De basissyntaxis is:

T extends U ? X : Y

Dit betekent: als T U uitbreidt, is het type X; anders is het Y.

Hier volgt een eenvoudig voorbeeld:

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

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

Voorwaardelijke typen kunnen functie-overloads vereenvoudigen door retourtypen dynamisch te bepalen:

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

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

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

Wanneer voorwaardelijke typen op unietypen worden toegepast, worden ze verdeeld over elk lid van de unie:

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

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

Je kunt voorwaardelijke typen combineren met gemapte typen voor krachtige typetransformaties:

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; }

Voorwaardelijke typen worden vaak gebruikt voor:

• Het afleiden van retourtypen of parameters.
• Het transformeren van unies en doorsneden.
• Het maken van hulpprogrammatypen zoals Exclude, Extract en NonNullable.

Maak een voorwaardelijk type dat controleert of een type een array is en in dat geval het elementtype retourneert; anders retourneert het type zichzelf.

Je hebt geleerd hoe je voorwaardelijke typen gebruikt om dynamische en herbruikbare typedefinities in TypeScript te maken. Oefen deze concepten om krachtigere en flexibelere TypeScript-code te schrijven!