La répétition de déclarations proches dans TypeScript invite à calculer un type de sortie depuis un type d’entrée. La clarté de leur relation compte davantage que les caractères économisés. Prenons un service fictif de notifications de livraison pour examiner les types conditionnels et infer, en les distinguant de la vérification réelle des données externes.
1. Un type conditionnel branche selon un type d’entrée
La documentation officielle des types conditionnels explique le choix du résultat selon une condition extends. Cet exemple produit un type littéral booléen selon que l’entrée est une chaîne. Ce n’est pas une fonction vérifiant les chaînes à l’exécution.
type IsText<T> = T extends string ? true : false;
type NameIsText = IsText<'parcel'>; // true
type CountIsText = IsText<3>; // false
Supposons que la fonction de notification reçoive un identifiant chaîne et une fonction interne un identifiant numérique. Avant les types conditionnels, expliquez cette distinction. Des noms séparés aident pour des sens différents ; si seule la notation change, uniformiser l’entrée peut être plus lisible. Ne cachez pas une conception de données ambiguë derrière une technique de types.
Écrivez les entrées et résultats attendus par paires. De petits exemples de chaînes, nombres, unions et entrées inattendues allègent la lecture des déclarations complexes. Vérifiez l’accord entre les commentaires et l’inférence de l’éditeur. Un nom de type naturel ne garantit pas le résultat calculé.
2. La distribution d’une union change le sens des tableaux
Si le paramètre de type est directement à gauche de la condition, celle-ci s’applique par distribution à chaque membre de l’union. Pour traiter l’union entière comme un seul ensemble, comparez la forme entourée de crochets.
type SeparateLists<T> = T extends unknown ? T[] : never;
type Together<T> = [T] extends [unknown] ? T[] : never;
type A = SeparateLists<string | number>; // string[] | number[]
type B = Together<string | number>; // (string | number)[]
const a: A = ['a', 'b'];
const b: B = ['a', 1];
Le premier résultat est un tableau de chaînes uniquement ou un tableau de nombres uniquement. Le second autorise les deux dans le même tableau. Le choix dépend de la règle : une liste de livraisons doit-elle utiliser un seul type de code ou chaque élément peut-il différer ? Les deux affichent des crochets, mais leurs contrats diffèrent.
En cas de problème, essayez chaque membre d’entrée plutôt que tout l’utilitaire complexe d’un coup. Comparez chaîne, nombre et union des deux. Clarifier l’intention de distribution explique aussi l’ajout de crochets. Conservez des exemples de valeurs autorisées dans la revue, en plus du résultat final.
3. infer nomme un type extrait d’une structure
Dans un type conditionnel, infer nomme une partie de la structure reconnue. Voici un petit type retirant un seul niveau de Promise.
type OneResult<T> = T extends Promise<infer Value> ? Value : T;
type Parcel = OneResult<Promise<{ tracking: string }>>;
type ParcelList = OneResult<Promise<string[]>>;
Ce code n’exécute ni n’attend un travail asynchrone ; il décrit la forme du résultat à la compilation. Un nom de fonction comme Resolved pourrait suggérer qu’une valeur est déjà arrivée : regardez donc le contexte d’utilisation du type. L’attente à l’exécution relève toujours du code asynchrone.
Pour un résultat attendu récursivement, consultez l’utilitaire standard Awaited avant d’étendre cet exemple à un niveau. La simplicité pédagogique diffère des exigences d’un outil partagé. Documentez les entrées donnant un résultat différent du type standard et la nécessité de cet écart avant d’introduire un utilitaire dans l’équipe.
4. Relier des noms d’événements par littéraux de gabarit
Les types littéraux de gabarit représentent des combinaisons de littéraux chaînes. Dans notre service, un nom d’événement peut combiner domaine et action.
type Scope = 'parcel' | 'address';
type Action = 'created' | 'updated';
type EventName = `${Scope}:${Action}`;
const event: EventName = 'parcel:created';
La compilation peut repérer une faute de nom, mais la validité métier de toutes les combinaisons reste une autre question. Si seul l’événement de suppression d’adresse est admis, le simple produit des domaines et actions peut mal exprimer la règle. Pensez d’abord à une correspondance explicite entre événements autorisés et payload.
Plus les événements sont nombreux, plus les noms réels doivent rester faciles à retrouver. Au lieu d’enchaîner plusieurs règles automatiques, on peut regrouper dans un fichier les noms envoyés aux systèmes externes. Comparez comment un nouveau collègue repérerait une erreur avant et après abstraction. Évaluez ensemble sophistication et facilité d’usage.
5. Vérifier le JSON externe à l’exécution
Ajouter User ou Parcel comme type d’une réponse API ne garantit pas sa structure réelle. Recevons une valeur externe en unknown et vérifions les champs requis.
function hasTracking(value: unknown): value is { tracking: string } {
return typeof value === 'object' && value !== null
&& 'tracking' in value && typeof value.tracking === 'string';
}
const incoming: unknown = { tracking: 'DEMO-001' };
if (hasTracking(incoming)) console.log(incoming.tracking);
Ce contrôle vérifie seulement que tracking est une chaîne. Il ne confirme ni l’existence du numéro ni le droit de l’utilisateur à consulter la livraison. Réduction du type, règles métier et autorisations sont des responsabilités distinctes. La documentation officielle sur le narrowing explique comment les conditions précisent le type.
6. Une courte démarche pour choisir ses outils de types
Notez deux valeurs réelles à autoriser et deux à rejeter. Exprimez ensuite le sens par unions ordinaires et déclarations explicites d’objets. Utilisez les types conditionnels ou infer si des relations répétées subsistent : leur raison devient claire. Si la lecture s’allonge beaucoup, extrayez seulement la partie commune et laissez le reste en types simples.
Exécutez enfin séparément vérifications de types et contrôles à l’exécution. Vérifier le rejet d’un nom d’événement invalide par le compilateur complète le test d’une erreur expliquée quand le serveur omet un champ. Après les petits exemples, rejoignez les frontières d’entrée réelles pour que les transformations contribuent à une application sûre.