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 Background Title How type aliases work Original type Original complex type type User = { name: string; age: number; email: string; } Arrow Definition type alias type alias type UserID = User; // or type ID = string | number; Arrow Usage Usage Use in code var id: UserID; var uid: ID; Lower part: application scenarios Application scenarios for type aliases Scenario 1 Basic type alias Scenario 2 Union type alias Scenario 3 Function type alias Scenario 4 Generic type alias Arrow marker

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 typetypedé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

// Alias de type : définir un alias pour un type union
// 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

// Utiliser un alias de type pour définir un type d'objet
// 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

// Alias de type union : définir les valeurs possibles pour un statut
// 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

// Alias de type tuple : définir des coordonnées
// 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

// Alias de type de fonction : définir un type de fonction de rappel
// 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

// Alias de type générique : définir un type de résultat
// 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

// Type mappé : rendre toutes les propriétés readonly
// 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

Recommandation :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.

Autres extensions