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 Background Title Type Guard - Type Narrowing Flow Left: Union Type Original Union Type string | number | boolean Arrow 1 typeof Middle: typeof string typeof === "string" Narrowed to string Arrow 2 Branch Right: Result Type determined Can access .length Bottom: Type Guard Types Type Guard Methods Method 1 typeof typeof x === "string" Primitive type Method 2 instanceof x instanceof Array Class instance Method 3 Custom guard x is String value is Type Method 4 in "prop" in x Property check Arrow markers

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

// Définir une fonction qui reçoit un type union
// 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

// Définir une classe Dog
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

// Définir une fonction de garde de type personnalisée
// 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 retourvalue 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

// Définir deux interfaces avec des propriétés différentes
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

// Définir l'interface Circle, en utilisant la propriété kind comme discriminant
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

// Définir un paramètre de fonction qui peut être 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é

// Une chaîne qui peut être undefined
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 êtrevalue 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.
Autres extensions