Comment créer et utiliser des types d'utilitaires TypeScript

TypeScript fournit un ensemble de types utilitaires ​​qui facilitent la transformation et la gestion des types existants. Ces types utilitaires intégrés permettent aux développeurs de manipuler les types de diverses manières, ce qui permet de simplifier le code et d'éviter les répétitions. Ce guide explore certains des types utilitaires les plus courants et la manière dont ils peuvent être créés et utilisés dans un projet TypeScript.

Que sont les types d’utilitaires TypeScript ?

Les types utilitaires dans TypeScript sont des types prédéfinis qui aident à transformer d'autres types. Ils peuvent être utilisés pour créer de nouveaux types basés sur des types existants en sélectionnant, en omettant ou en modifiant des propriétés. Ils jouent un rôle essentiel dans le maintien d'un code propre et réutilisable.

Types d'utilitaires TypeScript couramment utilisés

Voici quelques-uns des types d’utilitaires TypeScript les plus couramment utilisés:

• Partial<T> – Rend toutes les propriétés de type T facultatives.
• Required<T> – Rend toutes les propriétés de type T obligatoires.
• Readonly<T> – Rend toutes les propriétés de type T en lecture seule.
• Pick<T, K> – Sélectionne un ensemble de propriétés K du type T.
• Omit<T, K> – Supprime un ensemble de propriétés K du type T.
• Record<K, T> – Construit un type d’objet avec des clés de type K et des valeurs de type T.

Exemple: Utilisation de Partial<T>

Le type d'utilitaire Partial rend toutes les propriétés d'une interface facultatives. Voici comment il peut être utilisé:

interface User {
  name: string;
  age: number;
  email: string;
}

const updateUser = (user: Partial<User>) => {
  // Update logic
};

updateUser({ name: "John" });

Dans cet exemple, updateUser accepte un argument de type Partial<User>, ce qui signifie que seules certaines des propriétés de l'interface User sont requises.

Exemple: Utilisation de Pick<T, K>

L'utilitaire de type Pick permet de sélectionner un sous-ensemble de propriétés à partir d'un type:

interface User {
  name: string;
  age: number;
  email: string;
}

type UserContactInfo = Pick<User, "name" | "email">;

const contactInfo: UserContactInfo = {
  name: "John",
  email: "john@example.com"
};

Ici, Pick<User, “name” | “email”> crée un nouveau type UserContactInfo avec uniquement les propriétés name et email de l'interface User d'origine.

Exemple: Utilisation de Omit<T, K>

L'utilitaire Omit supprime les propriétés spécifiées d'un type:

interface User {
  name: string;
  age: number;
  email: string;
}

type UserWithoutEmail = Omit<User, "email">;

const user: UserWithoutEmail = {
  name: "John",
  age: 30
};

Dans cet exemple, le type UserWithoutEmail est créé en omettant la propriété email de l'interface User.

Création de types d'utilitaires personnalisés

Des types d'utilitaires personnalisés peuvent également être créés à l'aide des fonctionnalités de type avancées de TypeScript, telles que les types conditionnels, les types mappés, etc. Voici un exemple simple d'un type d'utilitaire personnalisé qui rend toutes les propriétés facultatives:

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

interface User {
  name: string;
  age: number;
  email: string;
}

const user: MyPartial<User> = {
  name: "Alice"
};

Ce type personnalisé MyPartial fonctionne de manière similaire au type utilitaire intégré Partial de TypeScript.

Conclusion

Les types utilitaires TypeScript sont une fonctionnalité essentielle pour travailler avec des types de manière flexible et réutilisable. En exploitant ces types utilitaires, le code peut être rendu plus concis et plus facile à gérer. Qu'il s'agisse d'utiliser des types utilitaires intégrés tels que Partial, Pick et Omit ou d'en créer des personnalisés, ils améliorent considérablement le système de types de TypeScript.