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 Background Title How Template Literal Types Work Input Type Input Type type Event = "click" | "focus" type Method = "get" | "post" Arrow Template Template Literal Template Literal Type type Name = `on${Capitalize}` type Path = `${Method}:/${string}` Arrow Output Type Output Type "onClick" "onFocus" "get:/..." Lower Half: Built-in Utility Types Built-in Utility Types Uppercase "hello" → "HELLO" Lowercase "HELLO" → "hello" Capitalize "hello" → "Hello" Uncapitalize "Hello" → "hello" Arrow Markers

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

// Définir un type littéral de chaîne de base
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

// Uppercase : Convertit une chaîne en majuscules
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

// Construire les types de noms d'événements
// `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

// Définir les types de méthodes HTTP
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

// Type de modèle avec des nombres
// ${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

// Type utilitaire pour ajouter un préfixe
// 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