Gardes de type TypeScript
Les gardes de type sont un mécanisme d'affinage de type très important en TypeScript.
Ils permettent aux développeurs d'utiliser des vérifications de conditions à l'exécution spécifiques afin que le compilateur TypeScript puisse inférer avec précision le type spécifique d'une variable.
Avec les gardes de type, nous pouvons accéder en toute sécurité aux propriétés et méthodes d'un type spécifique dans une variable de type union.
Pourquoi avons-nous besoin de gardes de type ?
En TypeScript, une variable peut être déclarée comme une union de plusieurs types.
Lorsque nous devons effectuer différentes opérations en fonction du type spécifique, le compilateur ne peut pas déterminer automatiquement le type concret actuel.
Les gardes de type sont le mécanisme clé pour résoudre ce problème.
Explication du concept :Le principe fondamental des gardes de type est l'« affinage de type ». Grâce à des vérifications conditionnelles, TypeScript réduit automatiquement un type union à un type spécifique.
Diagramme SVG : flux de garde de type
Garde de type typeof
typeof est la garde de type la plus couramment utilisée, servant à vérifier les types primitifs (string, number, boolean, etc.).
Il renvoie une chaîne indiquant le type de la valeur.
Utilisation de base de typeof
// Le paramètre value peut être de type string ou number
function printValue(value: string | number): void {
// Utiliser typeof pour vérifier le type
// Lorsque la condition if est vraie, TypeScript restreint automatiquement value au type string
if (typeof value === "string") {
// À ce stade, TypeScript sait que value est de type string
// Peut accéder en toute sécurité à la propriété length de la chaîne
console.log("Longueur de la chaîne : " + value.length);
} else {
// Dans la branche else, TypeScript sait que value n'est pas de type string
// Il ne peut être que de type number
// Peut effectuer des opérations mathématiques en toute sécurité
console.log("Nombre doublé : " + (value * 2));
}
}
// Appels de test
printValue("hello"); // Passer une chaîne de caractères
printValue(42); // Passer un nombre
Sortie :
字符串长度: 5 数字翻倍: 84
Types pris en charge par typeof :
- "string"- type string
- "number"- type number (y compris NaN et Infinity)
- "boolean"- type boolean
- "undefined"- type undefined
- "object"- type object (remarque : les tableaux et null sont aussi reconnus comme "object")
- "function"- type function
Remarque :typeof renvoie "object" pour les tableaux et null. Si vous devez distinguer précisément les tableaux des objets, vous devez utiliser d'autres méthodes.
Garde de type instanceof
instanceof est utilisé pour vérifier si un objet est une instance d'une certaine classe.
Il détermine le type en vérifiant la chaîne de prototypes de l'objet.
Utilisation de base de instanceof
class Dog {
// La méthode bark du chien
bark(): void {
console.log("Ouaf ouaf ouaf !");
}
}
// Définir une classe Cat
class Cat {
// La méthode meow du chat
meow(): void {
console.log("Miaou miaou miaou !");
}
}
// Fonction qui reçoit un type union
function makeSound(animal: Dog | Cat): void {
// Utiliser instanceof pour vérifier si animal est un Dog ou un Cat
// Lorsque la condition if est vraie, TypeScript réduit animal au type Dog
if (animal instanceof Dog) {
// À ce stade, vous pouvez appeler des méthodes spécifiques à Dog
animal.bark();
} else {
// Dans la branche else, TypeScript réduit animal au type Cat
animal.meow();
}
}
// Appels de test
makeSound(new Dog()); // Créer une instance de Dog et l'appeler
makeSound(new Cat()); // Créer une instance de Cat et l'appeler
Sortie :
Woof woof woof! Meow meow meow!
Explication :
instanceof vérifie la chaîne de prototypes de l'objet, donc il ne peut être utilisé qu'avec des instances de classe, pas avec des interfaces ou des alias de type.
Gardes de type personnalisées
Lorsque les opérateurs intégrés typeof et instanceof ne répondent pas aux exigences, vous pouvez créer des fonctions de garde de type personnalisées.
Les gardes de type personnalisées utilisentvalue is Typela syntaxe du type de retour.
Fonctions de garde personnalisées
// Le type de retour utilise le format "value is Type"
// Cela indique à TypeScript : lorsque la fonction renvoie true, le type du paramètre est string
function isString(value: any): value is string {
// Utilisez typeof pour vérifier s'il s'agit d'une chaîne de caractères
return typeof value === "string";
}
// Une autre garde personnalisée : vérifier s'il s'agit d'un nombre
function isNumber(value: any): value is number {
return typeof value === "number";
}
// Définir une garde de type pour les tableaux
function isArray(value: any): value is any[] {
return Array.isArray(value);
}
// Une fonction qui traite des valeurs
function processValue(value: string | number | any[]): void {
// Utilisez des gardes personnalisées pour la vérification des types
if (isString(value)) {
// TypeScript sait que value est de type string
// On peut appeler la méthode toUpperCase()
console.log("Chaîne en majuscules : " + value.toUpperCase());
} else if (isNumber(value)) {
// TypeScript sait que value est de type number
// On peut appeler la méthode toFixed()
console.log("Nombre formaté : " + value.toFixed(2));
} else if (isArray(value)) {
// TypeScript sait que value est de type array
console.log("Longueur du tableau : " + value.length);
}
}
// Appels de test
processValue("hello");
processValue(3.14159);
processValue([1, 2, 3, 4, 5]);
Sortie :
字符串转大写: HELLO 数字格式化: 3.14 数组长度: 5
Astuce :La clé d'une garde de type personnalisée est le type de retour
value is Type, qui est le marqueur que TypeScript utilise pour identifier une garde de type.
Garde de type de l'opérateur in
L'opérateur in permet de vérifier si un objet contient une certaine propriété.
En utilisant in dans des vérifications conditionnelles, TypeScript réduit automatiquement la portée du type de l'objet.
Utilisation de l'opérateur in
interface A {
a: string; // N'a que la propriété a
}
interface B {
b: number; // N'a que la propriété b
}
// Fonction qui reçoit un type union
function process(obj: A | B): void {
// Utiliser in pour vérifier si l'objet contient la propriété "a"
if ("a" in obj) {
// Dans la branche if, TypeScript sait que obj contient la propriété a
// Par conséquent, le type de obj est réduit à A
console.log("Propriété a de A : " + obj.a);
} else {
// Dans la branche else, obj ne contient pas la propriété a
// TypeScript sait que obj ne peut être que de type B
// Par conséquent, vous pouvez accéder en toute sécurité à la propriété b
console.log("Propriété b de B : " + obj.b);
}
}
// Appels de test
process({ a: "hello" }); // Passez un objet contenant la propriété a
process({ b: 42 }); // Passez un objet contenant la propriété b
Résultat de l'exécution:
A 的属性 a: hello B 的属性 b: 42
Unions discriminées et gardes de type
Une union discriminée est un modèle puissant qui distingue les membres d'un type union grâce à une propriété "discriminante" commune.
Combinée à des instructions switch ou à des vérifications if, des gardes de type complètes peuvent être mises en œuvre.
Implémentation d'une calculatrice avec des unions discriminées
interface Circle {
kind: "circle"; // Champ discriminant : la valeur est "circle"
radius: number; // rayon
}
// Définir l'interface Rectangle
interface Rectangle {
kind: "rectangle"; // Champ discriminant : la valeur est "rectangle"
width: number; // largeur
height: number; // hauteur
}
// Définir l'interface Triangle
interface Triangle {
kind: "triangle"; // Champ discriminant : la valeur est "triangle"
base: number; // base
height: number; // hauteur
}
// Définir le type union
type Shape = Circle | Rectangle | Triangle;
// Fonction pour calculer l'aire
function getArea(shape: Shape): number {
// Utiliser une instruction switch pour la garde de type
// En fonction de la valeur de la propriété kind, TypeScript réduit automatiquement le type
switch (shape.kind) {
case "circle":
// shape est réduit au type Circle
// On peut accéder à la propriété radius
return Math.PI * shape.radius ** 2;
case "rectangle":
// shape est réduit au type Rectangle
// On peut accéder aux propriétés width et height
return shape.width * shape.height;
case "triangle":
// shape est restreint au type Triangle
return 0.5 * shape.base * shape.height;
}
}
// Appels de test
var circle = { kind: "circle" as const, radius: 5 };
var rectangle = { kind: "rectangle" as const, width: 4, height: 6 };
var triangle = { kind: "triangle" as const, base: 3, height: 4 };
console.log("Aire du cercle : " + getArea(circle).toFixed(2));
console.log("Aire du rectangle : " + getArea(rectangle));
console.log("Aire du triangle : " + getArea(triangle));
Résultat de l'exécution:
圆形面积: 78.54 矩形面积: 24 三角形面积: 6
Remarque :Les unions discriminées sont l'un des modèles les plus recommandés en TypeScript. Elles distinguent différents membres de type via une propriété littérale commune (généralement kind ou type), ce qui rend le code à la fois sûr au niveau des types et facile à maintenir.
Vérifications de null et undefined
Lorsqu'on manipule des valeurs qui peuvent être null ou undefined, les vérifications d'égalité directes sont également des gardes de type efficaces.
Vérification de null
function getLength(str: string | null): number {
// Vérifier directement que str n'est pas égal à null
// Lorsque la condition est vraie, TypeScript sait que str n'est pas null
// À ce stade, on peut accéder aux propriétés de str en toute sécurité
if (str !== null) {
return str.length;
}
// Gestion du cas null
return 0;
}
// Appels de test
console.log(getLength("hello")); // Chaîne normale
console.log(getLength(null)); // Passer null
Résultat de l'exécution:
5 0
Astuce :Après avoir activé strictNullChecks, il est recommandé de toujours effectuer des vérifications de null. Le chaînage optionnel (?.) et la coalescence des nuls (??) peuvent être utilisés pour simplifier le code.
Réduction par véracité
En plus des vérifications de type explicites, TypeScript réduit également les plages de types via des assertions de véracité.
Réduction par véracité
function greet(name?: string): string {
// Utiliser l'opérateur de court-circuit : si name est undefined ou une chaîne vide, utiliser une valeur par défaut
// Dans le bloc de code après &&, TypeScript sait que name doit avoir une valeur
return name && "Hello, " + name;
}
// Test
console.log(greet("EXAMPLE"));
console.log(greet());
Résultat de l'exécution:
Hello, EXAMPLE Hello, undefined
Remarques importantes
- Les gardes de type doivent être utilisées dans des branches conditionnelles :Ce n'est qu'après avoir utilisé une garde de type pour une vérification conditionnelle que TypeScript effectuera un rétrécissement de type.
- Le type de retour doit être un prédicat de type :Le type de retour d'une garde de type personnalisée doit être
value is Typeformat - Les unions discriminées sont la meilleure pratique :Pour les types union complexes, il est recommandé d'utiliser le modèle d'union discriminée.
- Faites attention à l'exhaustivité du rétrécissement de type :Lors de l'utilisation d'instructions switch, il est recommandé de gérer toutes les branches possibles.
Recommandation :Lorsque vous traitez des types union, privilégiez le modèle d'union discriminée. Il rend non seulement le code plus clair, mais exploite également pleinement les capacités d'inférence de type de TypeScript.
Résumé
Les gardes de type sont une partie importante du système de types de TypeScript.
- typeof:La méthode la plus courante, adaptée pour vérifier les types primitifs.
- instanceof:Vérifie si un objet est une instance d'une classe spécifique.
- Gardes personnalisées :Grâce à
value is Typela syntaxe, des vérifications de type flexibles peuvent être mises en œuvre. - in:Vérifier si un objet contient une propriété spécifique.
- Unions discriminées :Modèle de bonne pratique recommandé, distinguant les types grâce à des champs discriminants.
- Rétrécissement par truthiness :Tirez parti des vérifications de véracité de JavaScript pour affiner les types.