Maîtriser les types littéraux de modèles TypeScript : améliorer la sécurité et l'expressivité du code-js tutoriel-php.cn

Mastering TypeScript

Très bien, passons au monde fascinant de la métaprogrammation au moment de la compilation dans TypeScript à l'aide de types littéraux de modèles. Cette fonctionnalité puissante nous permet de créer une magie au niveau du type vraiment cool qui peut rendre notre code plus sûr et plus expressif.

Tout d’abord, que sont exactement les types littéraux de modèles ? C'est un moyen de manipuler et de créer de nouveaux types basés sur des chaînes littérales. C'est comme avoir un mini langage de programmation juste pour vos types. Plutôt sympa, non ?

Commençons par un exemple simple :

type Greeting<T extends string> = `Hello, ${T}!`;
type Result = Greeting<"World">; // "Hello, World!"

Copier après la connexion

Ici, nous avons créé un type qui prend une chaîne et l'enveloppe dans un message de salutation. Le compilateur TypeScript détermine le type résultant au moment de la compilation. Cependant, cela ne fait qu’effleurer la surface.

Nous pouvons utiliser des types littéraux de modèles pour créer des transformations plus complexes. Par exemple, disons que nous voulons créer un type qui convertit Snake_case en CamelCase :

type SnakeToCamel<S extends string> = S extends `${infer T}_${infer U}`
  ? `${T}${Capitalize<SnakeToCamel<U>>}`
  : S;

type Result = SnakeToCamel<"hello_world_typescript">; // "helloWorldTypescript"

Copier après la connexion

Ce type transforme récursivement la chaîne d'entrée, en mettant chaque partie en majuscule après un trait de soulignement. Le mot-clé infer est crucial ici : il nous permet d'extraire des parties de la chaîne dans de nouvelles variables de type.

Mais pourquoi s'arrêter là ? Nous pouvons utiliser ces techniques pour créer des langages spécifiques à un domaine (DSL) entiers au sein de notre système de types. Imaginez créer un générateur de requêtes SQL de type sécurisé :

type Table = "users" | "posts" | "comments";
type Column = "id" | "name" | "email" | "content";

type Select<T extends Table, C extends Column> = `SELECT ${C} FROM ${T}`;
type Where<T extends string> = `WHERE ${T}`;

type Query<T extends Table, C extends Column, W extends string> = 
  `${Select<T, C>} ${Where<W>}`;

type UserQuery = Query<"users", "name" | "email", "id = 1">; 
// "SELECT name, email FROM users WHERE id = 1"

Copier après la connexion

Cette configuration garantit que nous sélectionnons uniquement des colonnes valides à partir de tables valides, toutes vérifiées au moment de la compilation. Fini les erreurs d'exécution dues à des noms de colonnes mal saisis !

Nous pouvons aller encore plus loin en implémentant des calculs au niveau du type plus complexes. Créons un type capable d'effectuer des opérations arithmétiques de base :

type Digit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
type AddDigits<A extends Digit, B extends Digit> = 
  // ... (implementation details omitted for brevity)

type Add<A extends string, B extends string> = 
  // ... (implementation details omitted for brevity)

type Result = Add<"123", "456">; // "579"

Copier après la connexion

Ce type peut ajouter deux nombres représentés sous forme de chaînes. L'implémentation réelle est assez complexe et implique beaucoup de types conditionnels et de récursion, mais le résultat final est une pure magie au moment de la compilation.

Une application pratique de ces techniques consiste à créer des schémas avancés de validation de formulaire. Nous pouvons définir un type qui décrit la forme de notre formulaire et l'utiliser pour générer des règles de validation :

type Form = {
  name: string;
  email: string;
  age: number;
};

type ValidationRule<T> = T extends string
  ? "isString"
  : T extends number
  ? "isNumber"
  : never;

type ValidationSchema<T> = {
  [K in keyof T]: ValidationRule<T[K]>;
};

type FormValidation = ValidationSchema<Form>;
// { name: "isString", email: "isString", age: "isNumber" }

Copier après la connexion

Ce schéma peut ensuite être utilisé pour générer du code de validation d'exécution, garantissant que notre logique de validation correspond toujours à nos définitions de type.

Les types littéraux de modèles nous permettent également de créer des API plus flexibles. Nous pouvons les utiliser pour implémenter le chaînage de méthodes avec une inférence de type appropriée :

type Chainable<T> = {
  set: <K extends string, V>(key: K, value: V) => Chainable<T & { [P in K]: V }>;
  get: () => T;
};

declare function createChainable<T>(): Chainable<T>;

const result = createChainable()
  .set("foo", 123)
  .set("bar", "hello")
  .get();

// result type: { foo: number, bar: string }

Copier après la connexion

Ce modèle nous permet de construire des objets étape par étape, le système de types gardant une trace des propriétés accumulées à chaque étape.

L'un des aspects les plus puissants de la métaprogrammation au moment de la compilation est la capacité de générer de nouveaux types basés sur ceux existants. Nous pouvons utiliser cela pour créer des types d’utilitaires qui transforment d’autres types de manière utile. Par exemple, créons un type qui rend toutes les propriétés d'un objet facultatives, mais uniquement au premier niveau :

type Greeting<T extends string> = `Hello, ${T}!`;
type Result = Greeting<"World">; // "Hello, World!"

Copier après la connexion

Ce type rend les propriétés de niveau supérieur facultatives, mais laisse les objets imbriqués inchangés. Il s'agit d'une version plus nuancée du type Partial intégré de TypeScript.

Nous pouvons également utiliser des types littéraux de modèles pour créer des messages d'erreur plus expressifs. Au lieu d'obtenir des erreurs de type énigmatiques, nous pouvons guider les développeurs vers le problème exact :

type SnakeToCamel<S extends string> = S extends `${infer T}_${infer U}`
  ? `${T}${Capitalize<SnakeToCamel<U>>}`
  : S;

type Result = SnakeToCamel<"hello_world_typescript">; // "helloWorldTypescript"

Copier après la connexion

Cette technique peut être particulièrement utile dans le développement de bibliothèques, où il est crucial de fournir des commentaires clairs aux utilisateurs.

Une autre application intéressante consiste à créer des émetteurs d'événements de type sécurisé. Nous pouvons utiliser des types littéraux de modèles pour garantir que les noms d'événements et leurs charges utiles correspondantes correspondent correctement :

type Table = "users" | "posts" | "comments";
type Column = "id" | "name" | "email" | "content";

type Select<T extends Table, C extends Column> = `SELECT ${C} FROM ${T}`;
type Where<T extends string> = `WHERE ${T}`;

type Query<T extends Table, C extends Column, W extends string> = 
  `${Select<T, C>} ${Where<W>}`;

type UserQuery = Query<"users", "name" | "email", "id = 1">; 
// "SELECT name, email FROM users WHERE id = 1"

Copier après la connexion

Cette configuration garantit que nous émettons et écoutons toujours des événements avec les types de charge utile corrects.

Les types littéraux de modèle peuvent également être utilisés pour implémenter des machines à états au niveau du type. Cela peut être incroyablement utile pour modéliser des flux de travail ou des protocoles complexes :

type Digit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
type AddDigits<A extends Digit, B extends Digit> = 
  // ... (implementation details omitted for brevity)

type Add<A extends string, B extends string> = 
  // ... (implementation details omitted for brevity)

type Result = Add<"123", "456">; // "579"

Copier après la connexion

Cette machine à états est entièrement sécurisée - elle n'autorisera pas les transitions non valides et suivra l'état actuel avec précision.

En conclusion, la métaprogrammation au moment de la compilation avec des types littéraux de modèles dans TypeScript ouvre un monde de possibilités. Cela nous permet de créer un code plus expressif, plus sûr et auto-documenté. Nous pouvons détecter les erreurs plus tôt, offrir de meilleures expériences aux développeurs et même générer du code basé sur les types. Bien que ces techniques puissent être complexes, elles offrent des outils puissants pour créer des systèmes robustes et flexibles. Comme pour toute fonctionnalité avancée, il est important de les utiliser judicieusement – parfois des solutions plus simples sont plus faciles à maintenir. Mais lorsqu'elle est bien utilisée, la métaprogrammation au moment de la compilation peut améliorer considérablement la qualité et la fiabilité de notre code TypeScript.