Types de littéraux de modèle TypeScript
Les types de littéraux de gabarit sont construits sur les types de littéraux de chaîne et prennent en charge la génération de nouveaux types de chaîne par interpolation.
Cela permet à TypeScript d'effectuer une vérification de type plus précise sur les chaînes, adaptée à des scénarios tels que les noms d'événements, les chemins et les noms de classes.
Diagramme SVG : Types de littéraux de gabarit
Pourquoi avons-nous besoin des types de littéraux de gabarit
En développement, nous devons souvent gérer des chaînes formatées, telles que les noms d'événements (onClick), les chemins d'API (get:/users), les noms de classes CSS (btn-primary-md), etc.
Le type string simple ne peut pas décrire précisément ces formats, mais les types littéraux de modèle nous permettent de définir précisément les types de ces chaînes.
Cela améliore grandement la sûreté de typage de TypeScript et réduit les erreurs d'exécution.
Explication du concept :Les types littéraux de modèle utilisent des accents graves (`` ` ``) et
${}la syntaxe d'interpolation pour définir des types de chaînes, semblable aux chaînes de modèle JavaScript, mais utilisée au niveau du type.
Syntaxe de base
Les types littéraux de modèle utilisent des accents graves et l'interpolation pour définir des types.
Exemple
type World = "world";
// Utiliser un type littéral de modèle
// `Hello ${World}` est équivalent à "Hello world"
type Greeting = `Hello ${World}`;
// On ne peut affecter que des chaînes qui correspondent à la définition du type
var greeting: Greeting = "Hello world";
console.log("Greeting: " + greeting);
Sortie :
问候: Hello world
Explication :Les types de littéraux de gabarit remplacent la position d'interpolation par la chaîne réelle, générant un nouveau type littéral.
Types utilitaires intégrés
TypeScript fournit quatre types utilitaires intégrés pour gérer la casse des chaînes.
Exemple
type UpperHello = Uppercase<"hello">; // "HELLO"
// Lowercase : Convertit une chaîne en minuscules
type LowerHELLO = Lowercase<"HELLO">; // "hello"
// Capitalize : Met en majuscule la première lettre d'une chaîne
type CapitalizedHello = Capitalize<"hello">; // "Hello"
// Uncapitalize : Met en minuscule la première lettre d'une chaîne
type UncapitalizedHello = Uncapitalize<"Hello">; // "hello"
console.log("Majuscules : " + UpperHello);
console.log("Minuscules : " + LowerHELLO);
console.log("Première lettre en majuscule : " + CapitalizedHello);
console.log("Première lettre en minuscule : " + UncapitalizedHello);
Sortie :
Uppercase: HELLO Lowercase: hello Capitalize: Hello Uncapitalize: hello
Cas d'utilisation :Ces types utilitaires sont très utiles dans les scénarios qui nécessitent un formatage unifié, comme les noms d'événements et les noms de méthodes.
Types d'événements
Les types de littéraux de modèle peuvent être utilisés pour définir précisément les types des noms d'événements.
Exemple
// `on${Capitalize<string>}` génère des chaînes commençant par "on" et dont la première lettre est en majuscule
type EventName = `on${Capitalize<string>}`;
// `handle${Capitalize<string>}` génère des chaînes commençant par "handle" et dont la première lettre est en majuscule
type Handler = `handle${Capitalize<string>}`;
// On ne peut assigner que des chaînes qui correspondent au format
var clickEvent: EventName = "onClick";
var focusEvent: EventName = "onFocus";
var handler: Handler = "handleSubmit";
console.log("Event: " + clickEvent);
console.log("Handler: " + handler);
Sortie :
事件: onClick 处理器: handleSubmit
Avantages :Avec les types littéraux de modèle, les formats incorrects comme "onclick" (en minuscules) seront rejetés par TypeScript.
Types de chemin
Les types littéraux de modèle peuvent être utilisés pour définir précisément les types de chemins d'API.
Exemple
type HttpMethod = "get" | "post" | "put" | "delete";
// Définir le format de chemin
type ApiEndpoint = `/${string}`; // Chaînes commençant par une barre oblique
// Combiner en un type de chemin d'API complet
type ApiPath = `${HttpMethod}${ApiEndpoint}`;
// On ne peut assigner que des chemins qui correspondent au format
var getUsers: ApiPath = "/get/users";
var createUser: ApiPath = "/post/users";
console.log("Chemin : " + getUsers);
console.log("Chemin : " + createUser);
Sortie :
路径: /get/users 路径: /post/users
Sécurité de type :Les chemins comme "/users" (sans préfixe de méthode) seront signalés comme des erreurs par TypeScript.
Exemple complexe
Les types littéraux de modèle peuvent combiner plusieurs types d'union pour générer toutes les combinaisons possibles.
Exemple
// ${number} correspond à n'importe quel nombre
type Row = `row${number}`;
type Row10 = Row; // row0, row1, row2... jusqu'à row9...
// Combiner plusieurs types
type Variant = "primary" | "secondary";
type Size = "sm" | "md" | "lg";
// Cela génère 6 combinaisons : btn-primary-sm, btn-primary-md, btn-primary-lg...
type ClassName = `btn-${Variant}-${Size}`;
// On ne peut assigner qu'une seule des 6 combinaisons générées
var className: ClassName = "btn-primary-md";
console.log("Nom de classe : " + className);
Sortie :
类名: btn-primary-md
Explosion des combinaisons :Les types de littéraux de modèle développent automatiquement toutes les combinaisons. Si les types union ont de nombreuses options, le type généré peut devenir très volumineux.
Types utilitaires personnalisés
Vous pouvez créer vos propres types utilitaires de littéraux de modèle.
Exemple
// T est une chaîne quelconque, P est le préfixe à ajouter
type Prefix<T extends string, P extends string> = `${P}${Capitalize<T>}`;
// Type utilitaire pour ajouter un suffixe
// T est une chaîne quelconque, S est le suffixe à ajouter
type Suffix<T extends string, S extends string> = `${Capitalize<T>}${S}`;
// Utiliser des types utilitaires personnalisés
type HandlerName = Prefix<"click", "on">;
type ButtonId = Suffix<"submit", "Btn">;
var handler: HandlerName = "onClick";
var id: ButtonId = "SubmitBtn";
console.log("Handler: " + handler);
console.log("ID: " + id);
Sortie :
处理器: onClick ID: SubmitBtn
Modèles génériques :Les types littéraux de modèle peuvent être combinés avec des génériques pour créer des types utilitaires réutilisables.
Notes
- Types d'interpolation :Dans un modèle, l'interpolation
${}peut être des chaînes spécifiques, des types union, string, number, etc. - Nombre de combinaisons :Lors de la combinaison de plusieurs types union, le type généré peut être très volumineux
- Gestion de la casse :Utilisez les types utilitaires intégrés pour gérer la casse des chaînes
Bonnes pratiques :L'utilisation de types littéraux de modèle pour gérer des chaînes avec des formats fixes tels que des noms d'événements, des chemins et des noms de classes permet d'obtenir une meilleure sécurité de type.
Résumé
Les types littéraux de modèle font partie du système de types puissant de TypeScript.
- Syntaxe du modèle :Utilisez
${T}l'interpolation pour construire des types - Utilitaires intégrés :Uppercase、Lowercase、Capitalize、Uncapitalize
- Cas d'utilisation :Noms d'événements, chemins d'API, noms de classes CSS, etc.
- Personnalisation :Créez des types utilitaires réutilisables
Recommandation :Dans les scénarios nécessitant des chaînes formatées, privilégiez l’utilisation des types de littéraux de modèle pour obtenir une vérification de type à la compilation.
Autres extensions