Les Aliases de Type en TypeScript

Introduction aux Aliases de Type

Dans TypeScript, les aliases de type fournissent des définitions qui peuvent être réutilisées avec aisance dans l'ensemble du code. Ceci s'oppose aux unions et intersections de types où les informations de type sont souvent répétés de manière explicite.

La Syntaxe des Aliases de Type

Pour créer un alias de type, il suffit d'utiliser le mot-clé type suivi d'un nom. Voici deux manières de le faire :

1. En définissant un objet qui décrit les membres et leurs types respectifs :

// Définition d'un type avec des membres
 type MonType = {  membreUn: string;  membreDeux: number;}
let nombrePrefere: MonType = {membreUn: "mon nombre préféré est", membreDeux: 42};

1. En se référant à d'autres types connus, comme un type d'union :

// Alternate definition that refers to known types
 type MonType = string | number;
let nombrePrefere: MonType = '42';

Chaque fois que ce nom est utilisé, TypeScript reconnaît qu'il fait référence à la valeur aliasée. Les alias de type se rapprochent des interfaces en termes de syntaxe et de comportement. Cependant, une différence notoire réside dans le fait qu'une interface peut voir ses membres ajoutés après sa définition, tandis qu'un alias de type est figé une fois défini.

Utilisation des Aliases de Type avec des Gardes de Type

Prenons comme exemple l'alias de type StringsIsh qui peut remplacer une union de types contenant plusieurs membres. Voici comment cela s'intègre dans la fonction logAllStrings() :

// Alias de type utilisant des gardes de type
 type StringsIsh = string | string[] | null | undefined;
 function logAllStrings(valeurs: StringsIsh) {  
  if (valeurs === null || typeof valeurs === 'undefined') return;
  if (typeof valeurs === 'string') {    
    console.log(valeurs);  
  } else {    
    valeurs.forEach(logAllStrings);  
  }
}
logAllStrings('bonjour'); // Ça marche
logAllStrings(['bonjour', 'monde']); // Ça marche aussi

La première garde de type vérifie si valeurs est soit null, soit undefined selon l'alias StringsIsh. Ensuite, la structure conditionnelle vérifie si valeurs est de type string. Dans le cas contraire, elle appelle récursivement logAllStrings.

Les Aliases de Type en tant que Types Génériques

Les aliases de type peuvent également être génériques et intégrer une description de type variée, incluant : - Types primitifs - Littéraux - Types d'objets

Prenons un exemple avec le type Result<T> qui peut contenir une valeur, de type T, ou un objet intégrant la valeur :

// Exemple d'alias de type générique
 type Result = T | { value: T };
 let value: Result = 'bonjour'; // Ça marche
 let autre: Result = { value: 'monde' }; // Ça marche aussi