Introduction aux types conditionnels

Les types conditionnels de TypeScript vous permettent de créer des types qui s’adaptent dynamiquement en fonction d’une condition, ce qui rend votre code plus flexible et réutilisable.

Ils utilisent une syntaxe similaire à celle de l’opérateur conditionnel (ternary) de JavaScript.

Que sont les types conditionnels ?

Les types conditionnels vous permettent de définir un type qui dépend d’un autre type. La syntaxe de base est la suivante :

T extends U ? X : Y

Cela signifie que si T étend U, le type est X ; sinon, il est Y.

Exemple de base des types conditionnels

Voici un exemple simple :

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

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

Utiliser les types conditionnels pour les surcharges de fonctions

Les types conditionnels peuvent simplifier les surcharges de fonctions en déterminant dynamiquement les types de retour :

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

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

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

Types conditionnels distributifs

Lorsque les types conditionnels sont appliqués à des types unions, ils sont répartis sur chaque membre de l’union :

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

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

Combiner les types conditionnels avec les types mappés

Vous pouvez combiner les types conditionnels avec les types mappés pour effectuer de puissantes transformations de types :

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

Cas d’utilisation courants des types conditionnels

Les types conditionnels sont couramment utilisés pour :

• Déduire les types de retour ou les paramètres.
• Transformer les unions et les intersections.
• Créer des types utilitaires tels que Exclude, Extract et NonNullable.

Exercice pratique

Créez un type conditionnel qui vérifie si un type est un tableau et qui, le cas échéant, renvoie le type de ses éléments ; sinon, il renvoie le type lui-même.

Félicitations !

Vous avez appris à utiliser les types conditionnels pour créer des définitions de types dynamiques et réutilisables en TypeScript. Mettez ces concepts en pratique pour écrire du code TypeScript plus puissant et plus flexible !