Types utilitaires TypeScript

Les types utilitaires sont une série de types avancés intégrés à TypeScript.

Ils aident les développeurs à créer et transformer rapidement des types, améliorant ainsi la réutilisabilité du code et la sécurité des types.

Les types utilitaires sont essentiellement des types génériques implémentés au moyen de types mappés et de types conditionnels.


Background Title TypeScript Utility Types Primitive Types Primitive Types interface User { id: number; name: string; email: string; } Arrow Utility Types Utility Types Partial<T> - All Optional Required<T> - All Required Readonly<T> - All Readonly Pick<T,K> - Select Properties Omit<T,K> - Exclude Properties Arrow Result Result Type type Result = { id?: number; name?: string; email?: string; } Lower Part Common Utility Types First Row Partial<T> All properties optional { a?: T } Required<T> All properties required { -? } Readonly<T> All properties readonly { readonly } Pick<T,K> Select specified properties { pick } Second Row (Fix Focus) Record<K,T> Construct Object Types Omit<T,K> Exclude Specified Properties Arrow Definition

Pourquoi les types utilitaires sont-ils nécessaires ?

Dans le développement TypeScript réel, nous devons souvent créer de nouveaux types à partir de types existants.

Créer manuellement ces types est non seulement fastidieux, mais aussi source d'erreurs.

Les types utilitaires offrent une manière déclarative de transformer et de créer des types, ce qui améliore grandement l'efficacité du développement.

Explication du concept :Les types utilitaires sont une série de types génériques prédéfinis dans TypeScript. Ils utilisent des types mappés et des types conditionnels pour transformer et générer des types.


Partial<T> - Propriétés facultatives

Partial rend toutes les propriétés du type T facultatives.

Cela est très utile lors de la création d'objets partiellement mis à jour ou de la gestion de données de formulaire.

Exemple

// Définir une interface utilisateur avec des propriétés requises
interface User {
    // ID utilisateur
    id: number;
    // Nom d'utilisateur
    name: string;
    // E-mail de l'utilisateur
    email: string;
}

// Partial : rend toutes les propriétés facultatives
// Toutes les propriétés du type transformé sont facultatives
type PartialUser = Partial<User>;

// Utiliser le type PartialUser
// Vous pouvez fournir seulement quelques propriétés, pas toutes
var user: PartialUser = { name: "Alice" };

console.log("Utilisateur partiel : " + JSON.stringify(user));

Résultat de l'exécution :

部分用户: {"name":"Alice"}

Scénarios d'application :Partial est souvent utilisé pour mettre à jour les données d'un objet. Par exemple : lorsqu'on met à jour seulement une partie des informations d'un utilisateur, il n'est pas nécessaire de transmettre l'objet utilisateur entier.


Required<T> - Propriétés requises

Required est l'opposé de Partial ; il rend toutes les propriétés optionnelles obligatoires.

Utilisez-le lorsque vous devez vous assurer qu'un objet contient toutes les propriétés.

Exemple

// Définir une interface de configuration avec toutes les propriétés optionnelles
interface Config {
    // Adresse du serveur
    host?: string;
    // Numéro de port
    port?: number;
}

// Required : rend obligatoires toutes les propriétés optionnelles
// Toutes les propriétés du type transformé sont obligatoires
type RequiredConfig = Required<Config>;

// Utiliser le type RequiredConfig
// Toutes les propriétés doivent être fournies
var config: RequiredConfig = { host: "localhost", port: 8080 };

console.log("Config: " + JSON.stringify(config));

Résultat de l'exécution :

配置: {"host":"localhost","port":8080}

Remarque :Required ne supprime pas seulement le marqueur optionnel (?), mais supprime aussi le modificateur readonly.


Readonly<T> - Propriétés en lecture seule

Readonly définit toutes les propriétés en lecture seule.

Il est très utile lors de la création d'objets qui ne peuvent pas être modifiés après leur création.

Exemple

// Définir une interface pour l'utilisateur
interface User {
    // Nom d'utilisateur
    name: string;
    // Âge de l'utilisateur
    age: number;
}

// Readonly : rend toutes les propriétés readonly
// Aucune des propriétés du type transformé ne peut être modifiée
type ReadonlyUser = Readonly<User>;

// Créer un objet utilisateur readonly
var user: ReadonlyUser = { name: "Alice", age: 25 };

// Tenter de modifier une propriété readonly provoquera une erreur
// user.name = "Bob"; // Erreur : une propriété readonly ne peut pas être modifiée

console.log("Utilisateur en lecture seule : " + JSON.stringify(user));

Scénarios d'application :Readonly est souvent utilisé pour définir des objets de configuration, des mappages de valeurs d'énumération et d'autres données qui ne doivent pas être modifiées.


Pick<T, K> - Sélection de propriétés

Pick sélectionne les propriétés K spécifiées du type T pour former un nouveau type.

Utilisez-le lorsque vous n'avez besoin que de certaines propriétés d'un type.

Exemple

// Définir une interface utilisateur complète
interface User {
    // ID utilisateur
    id: number;
    // Nom d'utilisateur
    name: string;
    // E-mail de l'utilisateur
    email: string;
    // Mot de passe utilisateur
    password: string;
}

// Pick : sélectionner les propriétés spécifiées pour former un nouveau type
// Sélectionner les propriétés id et name de User
type UserBasicInfo = Pick<User, "id" | "name">;

// Utiliser le type sélectionné
var user: UserBasicInfo = { id: 1, name: "Alice" };

console.log("Informations de base de l'utilisateur : " + JSON.stringify(user));

Résultat de l'exécution :

用户基本信息: {"id":1,"name":"Alice"}

Comparaison :Combiner Pick et Partial peut créer un type qui contient uniquement certaines propriétés optionnelles.


Omit<T, K> - Exclure des propriétés

Omit exclut les propriétés spécifiées K du type T et renvoie un nouveau type composé des propriétés restantes.

C'est l'opposé de Pick et il est utilisé pour supprimer les propriétés inutiles.

Exemple

// Définir une interface utilisateur complète
interface User {
    // ID utilisateur
    id: number;
    // Nom d'utilisateur
    name: string;
    // E-mail de l'utilisateur
    email: string;
    // Mot de passe utilisateur
    password: string;
}

// Omit : exclure les propriétés spécifiées
// Exclure la propriété password de User
type UserWithoutPassword = Omit<User, "password">;

// Utiliser le type résultant après exclusion
var user: UserWithoutPassword = { id: 1, name: "Alice", email: "a@b.com" };

console.log("Utilisateur sans mot de passe : " + JSON.stringify(user));

Résultat de l'exécution :

无密码用户: {"id":1,"name":"Alice","email":"a@b.com"}

Astuce :Omit est l'inverse de Pick. Lorsque vous devez exclure quelques propriétés, utilisez Omit ; lorsque vous devez sélectionner quelques propriétés, utilisez Pick.


Record<K, T> - Construction de types d'objets

Record construit un type d'objet avec des clés de type K et des valeurs de type T.

Il est souvent utilisé pour créer des mappages clé-valeur, des types de dictionnaire, etc.

Exemple

// Définir un type de rôle
type Role = "admin" | "user" | "guest";

// Record : construit un type d'objet
// Les clés sont de type Role, les valeurs sont de type tableau de chaînes
type RolePermissions = Record<Role, string[]>;

// Utiliser Record pour créer un mappage de permissions
var permissions: RolePermissions = {
    // Admin dispose de toutes les permissions
    admin: ["read", "write", "delete"],
    // L'utilisateur standard dispose des permissions de lecture et d'écriture
    user: ["read", "write"],
    // L'invité dispose uniquement de la permission de lecture
    guest: ["read"]
};

console.log("Permissions administrateur : " + permissions.admin);
console.log("Permissions invité : " + permissions.guest);

Résultat de l'exécution :

管理员权限: read,write,delete
访客权限: read

Scénarios d'application :Record est souvent utilisé dans des scénarios où les valeurs doivent être rapidement recherchées par clé, comme les mappages de configuration, les mappages d'état et les mappages de permissions.


Exclude<T, U> - Exclusion de types

Exclude supprime du type T tous les types qui sont assignables au type U.

Principalement utilisé pour les types union, en excluant des membres de type spécifiques.

Exemple

// Définir un type union contenant a, b, c, d
type T = "a" | "b" | "c" | "d";

// Exclude : supprimer les types spécifiés de T
// Exclude "a", "b", "c", ne laissant que "d"
type NonABC = Exclude<T, "a" | "b" | "c">;

// En utilisant le type exclu, seul "d" peut être assigné
var value: NonABC = "d";

console.log("Valeur : " + value);

Sortie :

值: d

Explication :Le principe d'Exclude est : si un type dans T est assignable à U, le retirer de T.


Extract<T, U> - Extraction de types

Extract est l'opposé d'Exclude ; il extrait du type T les types qui sont assignables au type U.

Utilisé pour filtrer des membres spécifiques d'un type union.

Exemple

// Définir un type union mixte contenant des chaînes et des nombres
type T = "a" | "b" | "c" | 1 | 2 | 3;

// Extract : extraire les types spécifiés de T
// Extraire tous les types de chaîne : "a", "b", "c"
type Letters = Extract<T, string>;

// Utiliser le type extrait
var letter: Letters = "a";

console.log("Letters: " + letter);

Sortie :

字母: a

Comparaison :Extract et Exclude sont complémentaires. Extract(T, U) est équivalent à Exclude(T, Exclude<T, U>).


NonNullable<T> - Exclure les valeurs nullish

NonNullable supprime null et undefined du type T.

Utilisez-le pour garantir qu'un type ne contient pas de valeurs nullish.

Exemple

// Définir un type mixte contenant des chaînes, null, undefined et des nombres
type T = string | null | undefined | nombre;

// NonNullable : supprimer null et undefined
// Après conversion, il ne reste que string et number
type NotNull = NonNullable<T>;

// Utiliser le type non-nullable
var value: NotNull = "hello";
value = 42;

// L'assignation de null provoquera une erreur
// value = null; // Erreur : impossible d'assigner null

console.log("Valeur : " + value);

Explication :NonNullable<T> équivaut à Exclude<T, null | undefined>.


ReturnType<T> - Obtention du type de retour

ReturnType obtient le type de retour d'un type de fonction T.

Souvent utilisé pour extraire le type de retour d'une fonction existante.

Exemple

// Définir une fonction pour obtenir un utilisateur
function getUser() {
    return { name: "Alice", age: 25 };
}

// Définir une fonction pour obtenir config
function getConfig() {
    return { host: "localhost", port: 8080 };
}

// ReturnType : obtenir le type de retour de la fonction
// Extraire le type de retour de la fonction getUser
type UserType = ReturnType<typeof getUser>;
// Extraire le type de retour de la fonction getConfig
type ConfigType = ReturnType<typeof getConfig>;

// Utiliser les types de retour extraits pour créer des objets
var user: UserType = { name: "Bob", age: 30 };
var config: ConfigType = { host: "example.com", port: 3000 };

console.log("Utilisateur : " + JSON.stringify(user));
console.log("Config: " + JSON.stringify(config));

Sortie :

User: {"name":"Bob","age":30}
配置: {"host":"example.com","port":3000}

Astuce :T dans ReturnType<T> doit être un type de fonction. Vous pouvez utiliser typeof pour obtenir le type d'une fonction.


Notes

  • Les types utilitaires sont tous génériques :Lorsque vous les utilisez, passez des arguments de type concrets
  • Readonly et optionnel :Les types utilitaires peuvent être combinés, par ex., Partial<Readonly<T>>
  • Types intégrés :Ces types utilitaires sont intégrés à TypeScript et ne nécessitent aucune installation
  • Types utilitaires personnalisés :Vous pouvez créer des types utilitaires personnalisés basés sur des types mappés et des types conditionnels

Avancé :Si les types utilitaires intégrés ne répondent pas à vos besoins, vous pouvez implémenter des types utilitaires personnalisés en vous référant au code source de TypeScript.


Résumé

Les types utilitaires TypeScript sont une partie importante du système de types.

  • Partial<T>:Rendre toutes les propriétés facultatives
  • Required<T>:Rendre toutes les propriétés obligatoires
  • Readonly<T>:Rendre toutes les propriétés en lecture seule
  • Pick<T,K>:Sélectionner les propriétés spécifiées
  • Omit<T,K>:Exclure les propriétés spécifiées
  • Record<K,T>:Construire des types d'objet
  • Exclude/Extract:Filtrage de types
  • NonNullable:Exclure null et undefined
  • ReturnType:Obtenir le type de retour de la fonction

Bonnes pratiques :Une bonne utilisation des types utilitaires peut rendre le code plus sûr au niveau des types, réduire les définitions de types répétitives et améliorer la maintenabilité du code.


Autres extensions