Introduction aux types mappés TypeScript

Les types mappés dans TypeScript permettent de créer de nouveaux types en transformant les types existants. Ils constituent un outil puissant pour gérer des opérations de type complexes et garantir la sécurité des types dans les applications TypeScript. Cet article présente les types mappés, explique leur syntaxe et fournit des exemples pour illustrer leur utilisation.

Que sont les types mappés ?

Les types mappés permettent de créer de nouveaux types en appliquant une transformation à chaque propriété d'un type existant. Ils sont souvent utilisés pour modifier ou étendre les types de manière flexible. La syntaxe de base d'un type mappé est la suivante:

type MappedType = {
  [K in keyof T]: NewType;
};

Dans cette syntaxe:

• T est le type d'origine.
• K représente chaque clé dans T.
• NewType est le nouveau type attribué à chaque propriété.

Exemple de base de types mappés

Voici un exemple simple d'un type mappé qui convertit toutes les propriétés d'un type donné en lecture seule:

type ReadOnly = {
  readonly [K in keyof T]: T[K];
};

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

type ReadOnlyUser = ReadOnly;

Dans cet exemple, le type mappé ReadOnly transforme toutes les propriétés du type User en lecture seule, ce qui donne un nouveau type ReadOnlyUser où toutes les propriétés sont immuables.

Types mappés avec transformations de type

Les types mappés peuvent également être utilisés pour transformer des types de manière plus complexe. Par exemple, un type mappé qui rend toutes les propriétés facultatives:

type Partial = {
  [K in keyof T]?: T[K];
};

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

type PartialUser = Partial;

Dans cet exemple, le type mappé Partial rend toutes les propriétés du type User facultatives, ce qui donne un nouveau type PartialUser où chaque propriété est facultative.

Utilisation de types mappés avec des types conditionnels

Les types mappés peuvent être combinés avec des types conditionnels pour des opérations de type plus sophistiquées. Par exemple, créer un type qui inclut uniquement les propriétés d'un certain type:

type OnlyStrings = {
  [K in keyof T]: T[K] extends string ? T[K] : never;
};

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

type StringProperties = OnlyStrings;

Dans cet exemple, le type mappé OnlyStrings filtre les propriétés qui ne sont pas de type string, ce qui génère un nouveau type StringProperties qui inclut uniquement les propriétés de chaîne du type User.

Types mappés avancés

Les cas d'utilisation avancés des types mappés incluent la création de types qui modifient les types existants en fonction de diverses conditions. Par exemple, un type mappé qui ajoute un suffixe à chaque nom de propriété:

type WithSuffix<T, S extends string> = {
  [K in keyof T as `${string & K}${S}`]: T[K];
};

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

type UserWithSuffix = WithSuffix<User, "Prop">;

Dans cet exemple, le type mappé WithSuffix ajoute un suffixe à chaque nom de propriété du type User, ce qui donne un nouveau type UserWithSuffix où les noms de propriété ont le suffixe spécifié.

Conclusion

Les types mappés dans TypeScript sont une fonctionnalité polyvalente qui permet aux développeurs de créer de nouveaux types en transformant les types existants. En comprenant et en utilisant les types mappés, les développeurs peuvent gérer des transformations de types complexes et garantir une plus grande sécurité de type dans leur code TypeScript. Les types mappés offrent de puissantes fonctionnalités pour améliorer et personnaliser les définitions de type dans les applications TypeScript.