Alias de type TypeScript
Un alias de type est utilisé pour créer un alias pour un type existant, rendant le code plus propre et plus facile à lire.
Avec les alias de type, vous pouvez définir un nom court pour des types complexes, ce qui améliore la maintenabilité du code.
Diagramme SVG : alias de type
Pourquoi avons-nous besoin d'alias de type
Lorsqu'un même type complexe est utilisé plusieurs fois dans le code, écrire le type complet à chaque fois devient verbeux.
Les alias de type peuvent définir un nom concis pour des types complexes, ce qui rend le code plus lisible et plus facile à maintenir.
Les alias de type sont particulièrement utiles lorsqu'on travaille avec des types complexes tels que les types union, les types de fonction et les tuples.
Explication du concept :Utilisation des alias de type
typedéfini avec le mot-clé `type` ; il donne simplement un nouveau nom à un type existant et ne crée pas un nouveau type.
Utilisation de base
Utilisez le mot-clé `type` pour définir un alias pour un type.
Exemple
// ID peut être une chaîne ou un nombre
type ID = string | number;
// Alias de type : définir un alias pour un type objet
// Point représente un point de coordonnées
type Point = { x: number; y: number };
// Utilisez l'alias de type
var userId: ID = "123";
var productId: ID = 456;
// Utiliser l'alias de type Point
var point: Point = { x: 10, y: 20 };
console.log("ID utilisateur : " + userId);
console.log("ID produit : " + productId);
console.log("Coordonnées : " + JSON.stringify(point));
Sortie :
用户ID: 123
产品ID: 456
坐标: {"x":10,"y":20}
Explication :Un alias de type donne simplement un nouveau nom à un type ; il ne génère aucun code réel après compilation et est utilisé entièrement pour la vérification de type pendant le développement.
Interface vs alias de type
Les alias de type et les interfaces sont très similaires ; les deux peuvent être utilisés pour définir des types d'objet, mais il existe quelques différences subtiles.
Exemple
// type peut définir n'importe quel type, pas seulement des objets
type PersonType = {
name: string;
age: number;
};
// Utiliser une interface pour définir un type d'objet
// Les interfaces prennent en charge la fusion de déclarations et peuvent être implémentées par des classes
interface PersonInterface {
name: string;
age: number;
}
// Les deux peuvent être utilisés pour déclarer des types de variables
var person1: PersonType = { name: "Alice", age: 25 };
var person2: PersonInterface = { name: "Bob", age: 30 };
console.log("PersonType: " + JSON.stringify(person1));
console.log("PersonInterface: " + JSON.stringify(person2));
Différences :type peut définir n'importe quel type (types union, tuples, types de fonction, etc.), tandis que les interfaces sont principalement utilisées pour les types d'objet. Les interfaces prennent en charge la fusion de déclarations, mais ce n'est pas le cas de type.
Alias de type et types union
Les alias de type sont parfaits pour définir des types union, ce qui rend le code plus clair.
Exemple
// Le statut ne peut être que l'un de ces trois littéraux de chaîne
type Status = "pending" | "success" | "error";
// Alias de type union : définir plusieurs types de retour possibles
// Result peut être une chaîne, un nombre ou un booléen
type Result = string | number | boolean;
// Utiliser l'alias de type union
function getStatus(status: Status): void {
console.log("Statut : " + status);
}
getStatus("success");
getStatus("error");
// Utiliser le type Result
var result: Result = "hello";
result = 42;
console.log("Résultat : " + result);
Sortie :
Status: success Status: error 结果: 42
Scénarios d'application :Les alias de type union sont souvent utilisés pour définir des codes de statut, des types d'erreur, des valeurs de retour d'API et des scénarios similaires.
Alias de type et tuples
Les alias de type peuvent aussi être utilisés pour définir des types tuples.
Exemple
// Coordinate est un tuple contenant deux nombres
type Coordinate = [number, number];
// Alias de type tuple : définir le nom et l'âge
// NameAge est un tuple composé d'une chaîne et d'un nombre
type NameAge = [string, number];
// Utiliser l'alias de type tuple
var coord: Coordinate = [10, 20];
var person: NameAge = ["Alice", 25];
console.log("Coordonnées : " + coord);
console.log("Info : " + person[0] + ", " + person[1]);
Explication :Les alias de type tuple rendent l'utilisation des tuples plus claire et évitent de devoir écrire le type tuple complet à chaque fois.
Alias de type et fonctions
Les alias de type peuvent simplifier les déclarations de type de fonction.
Exemple
// Le callback prend un paramètre de type string et retourne void
type Callback = (result: string) => void;
// Alias de type de fonction : définir un type de fonction d'opération mathématique
// MathOperation prend deux paramètres de type number et retourne un number
type MathOperation = (a: number, b: number) => number;
// Utiliser l'alias de type de fonction
var add: MathOperation = function(a, b) { return a + b; };
var multiply: MathOperation = function(a, b) { return a * b; };
console.log("Addition: " + add(2, 3));
console.log("Multiplication: " + multiply(4, 5));
Sortie :
加法: 5 乘法: 20
Avantages :Les alias de type de fonction rendent les déclarations de type de fonction plus concises, surtout lorsque la même signature de fonction est nécessaire plusieurs fois.
Alias de type et génériques
Les alias de type peuvent être utilisés avec des génériques pour créer des définitions de type réutilisables.
Exemple
// Result<T> est un type générique ; T est le type de données en cas de succès
type Result<T> = { success: boolean; data?: T; error?: string };
// Alias de type générique : définir un type de paire clé-valeur
// Pair<K, V> a deux paramètres de type
type Pair<K, V> = { key: K; value: V };
// Utiliser l'alias de type générique
var result: Result<string> = { success: true, data: "Hello" };
var pair: Pair<string, number> = { key: "age", value: 25 };
console.log("Résultat : " + JSON.stringify(result));
console.log("Paire clé-valeur : " + JSON.stringify(pair));
Sortie :
结果: {"success":true,"data":"Hello"}
键值对: {"key":"age","value":25}
Avantages des génériques :Les alias de type génériques peuvent s'adapter à différents types de données, améliorant ainsi la réutilisation du code.
Alias de type et types mappés
Les alias de type peuvent être combinés avec des types mappés pour créer de puissantes transformations de type.
Exemple
// Readonly<T> parcourt toutes les propriétés de T et ajoute readonly
type Readonly<T> = { readonly [P in keyof T]: T[P] };
// Type mappé : rendre toutes les propriétés optionnelles
// Partial<T> parcourt toutes les propriétés de T et ajoute ?
type Partial<T> = { [P in keyof T]?: T[P] };
// Définir une interface pour l'utilisateur
interface User {
name: string;
age: number;
}
// Utiliser des alias de type mappés
var readonlyUser: Readonly<User> = { name: "Alice", age: 25 };
// readonlyUser.name = "Bob"; // Erreur : la propriété readonly ne peut pas être modifiée
var partialUser: Partial<User> = { name: "Bob" };
console.log("Utilisateur en lecture seule : " + JSON.stringify(readonlyUser));
console.log("Utilisateur partiel : " + JSON.stringify(partialUser));
Astuce :Les types mappés sont une fonctionnalité très puissante de TypeScript, vous permettant de créer de nouvelles variations de types basées sur des types existants.
Notes
- Ne peut pas être redéfini :Le même alias de type ne peut pas être redéfini (les interfaces peuvent être fusionnées par déclaration)
- Valable uniquement à la compilation :Les alias de type ne produisent aucun code après compilation
- La lisibilité avant tout :N'abusez pas des alias de type ; un code concis et clair est préférable
Bonnes pratiques :Utilisez des alias de type lorsqu'un type doit être réutilisé ou lorsque le nom du type est trop long. Pour les types d'objets simples, vous pouvez choisir type ou interface selon les préférences de votre équipe.
Résumé
Les alias de type sont une fonctionnalité très utile dans TypeScript.
- Utilisation de base :Utilisez le mot-clé `type` pour définir un alias pour des types complexes
- Types union :Définissez des combinaisons de plusieurs types possibles
- Types de fonctions :Simplifiez les déclarations de type de fonction
- Génériques :Créer des types génériques réutilisables
- Types mappés :Créer de nouveaux types à partir de types existants
Autres extensionsRecommandation :Utiliser des alias de type de manière appropriée peut rendre le code plus clair, mais ne les utilisez pas à l'excès. Garder le code concis et lisible est ce qui importe le plus.