Introduction aux types mappés

Les types mappés vous permettent de transformer des types existants en nouveaux types en appliquant des opérations à chaque propriété d’un type.

Ils sont particulièrement utiles pour créer des structures de types flexibles et réutilisables dans TypeScript.

Que sont les types mappés ?

Les types mappés utilisent une syntaxe telle que { [P in keyof T]: T[P] } pour parcourir les propriétés d’un type T.

Exemple simple de types mappés

Voici un exemple simple d’utilisation d’un type mappé pour créer une version en lecture seule d’un type :

type User = {
  name: string;
  age: number;
};

type ReadonlyUser = {
  readonly [P in keyof User]: User[P];
};

Utiliser les types mappés intégrés

TypeScript fournit plusieurs types mappés intégrés, tels que :

• Readonly<T> : rend toutes les propriétés de T accessibles en lecture seule.
• Partial<T> : rend toutes les propriétés de T facultatives.
• Required<T> : rend toutes les propriétés de T obligatoires.

type User = {
  name: string;
  age: number;
};

// Example of Partial
const user: Partial<User> = {
  name: 'John',
};

Effectuer un mappage sur des unions

Les types mappés peuvent également être utilisés avec des types union pour créer de nouveaux types combinés :

type Status = 'active' | 'inactive';

type StatusFlags = {
  [K in Status]: boolean;
};

const flags: StatusFlags = {
  active: true,
  inactive: false,
};

Types mappés conditionnels

Vous pouvez utiliser des types conditionnels avec des types mappés pour créer des transformations de types plus complexes.

type User = {
  name: string;
  age?: number;
};

type NonOptional<T> = {
  [K in keyof T]-?: T[K];
};

type RequiredUser = NonOptional<User>;

Exemple avancé : exclure des propriétés

Voici comment créer un type mappé pour exclure certaines propriétés :

type User = {
  id: number;
  name: string;
  password: string;
};

type PublicUser = {
  [K in keyof User as Exclude<K, 'password'>]: User[K];
};

Exercice pratique

Créez un type mappé qui ajoute un modificateur readonly à toutes les propriétés d’un type Product. Testez-le en déclarant une variable du nouveau type.

Félicitations !

Vous avez appris à utiliser les types mappés pour transformer dynamiquement des types existants en nouveaux types. Entraînez-vous à appliquer ces techniques pour rendre votre code TypeScript encore plus puissant !