Types Mappés

Les types mappés permettent de créer de nouveaux types à partir de types existants, en transformant les propriétés une par une. Ils sont basés sur la syntaxe des boucles sur les clés, en utilisant l'opérateur keyof.

type Mapped<T> = {
  [P in keyof T]: T[P];
};

Cet exemple est un type mappé identique à l'original : il parcourt chaque clé P dans keyof T et lui affecte le même type T[P].

Modificateurs de mutabilité et d'optionalité

Nous pouvons ajouter ou supprimer des modificateurs comme readonly et ? (optionalité) en faisant précéder par + (ajouter, par défaut) ou - (supprimer).

Par exemple, pour supprimer l'optionalité de toutes les propriétés d'un type (les rendant obligatoires) :

type Concrete<T> = {
  [P in keyof T]-?: T[P];
};

Le modificateur -? supprime le drapeau d'optionalité de chaque propriété.

Remappage des clés avec as

Dans TypeScript 4.1+, il est possible de remapper les clés d'un type mappé en utilisant la clause as et les types littéraux de modèles (template literal types).

type ScriviSetters<T> = {
  [K in keyof T as `set${Capitalize<string & K>}`]: (value: T[K]) => void;
};

Ici, nous changeons le nom de chaque propriété K en set[CléCapitalisée] et changeons son type en une fonction setter.

À vous de jouer

Exercice 1 : Rendre les propriétés nullables

Exercice 2 : Générer des Getters dynamiques avec as