TypeScript
Gardes de type définis par l'utilisateur

Syntaxe

• typeof x === "nom du type"
• x instanceof TypeName
• function (foo: any): foo est TypeName {/ * code retournant booléen * /}

Remarques

Utiliser instanceof

instanceof nécessite que la variable soit de type any .

Ce code ( essayez-le ):

class Pet { }
class Dog extends Pet {
    bark() {
        console.log("woof");
    }
}
class Cat extends Pet {
    purr() {
        console.log("meow");
    }
}

function example(foo: any) {
    if (foo instanceof Dog) {
        // foo is type Dog in this block
        foo.bark();
    }

    if (foo instanceof Cat) {
        // foo is type Cat in this block
        foo.purr();
    }
}

example(new Dog());
example(new Cat());

estampes

woof
meom

à la console.

En utilisant typeof

typeof est utilisé lorsque vous devez distinguer les types number , string , boolean et symbol . Les autres constantes de chaîne ne seront pas erronées, mais ne seront pas non plus utilisées pour restreindre les types.

Contrairement à instanceof , typeof fonctionnera avec une variable de tout type. Dans l'exemple ci-dessous, foo peut être saisi en tant que number | string sans issue.

Ce code ( essayez-le ):

function example(foo: any) {
    if (typeof foo === "number") {
        // foo is type number in this block
        console.log(foo + 100);
    }

    if (typeof foo === "string") {
        // fooi is type string in this block
        console.log("not a number: " + foo);
    }
}

example(23);
example("foo");

estampes

123
not a number: foo

Fonctions de protection de type

Vous pouvez déclarer des fonctions qui servent de gardes de type en utilisant la logique de votre choix.

Ils prennent la forme:

function functionName(variableName: any): variableName is DesiredType {
    // body that returns boolean
}

Si la fonction renvoie true, TypeScript restreindra le type à DesiredType dans tout bloc protégé par un appel à la fonction.

Par exemple ( essayez-le ):

function isString(test: any): test is string {
    return typeof test === "string";
}

function example(foo: any) {
    if (isString(foo)) {
        // foo is type as a string in this block
        console.log("it's a string: " + foo);
    } else {
        // foo is type any in this block
        console.log("don't know what this is! [" + foo + "]");
    }
}

example("hello world");          // prints "it's a string: hello world"
example({ something: "else" });  // prints "don't know what this is! [[object Object]]"

Le prédicat de type de fonction d'un garde (le foo is Bar dans la position du type de retour de fonction) est utilisé au moment de la compilation pour restreindre les types, le corps de la fonction est utilisé lors de l'exécution. Le prédicat de type et la fonction doivent être compatibles ou votre code ne fonctionnera pas.

Les fonctions de type guard n'ont pas à utiliser typeof ou instanceof , elles peuvent utiliser une logique plus compliquée.

Par exemple, ce code détermine si vous avez un objet jQuery en vérifiant sa chaîne de version.

function isJQuery(foo): foo is JQuery {
    // test for jQuery's version string
    return foo.jquery !== undefined;
}

function example(foo) {
    if (isJQuery(foo)) {
        // foo is typed JQuery here
        foo.eq(0);
    }
}