TypeScript
Type Guards definiti dall'utente

Sintassi

• typeof x === "nome tipo"
• x instanceof TypeName
• function (foo: any): foo is TypeName {/ * code return boolean * /}

Osservazioni

Utilizzando instanceof

instanceof richiede che la variabile sia di tipo any .

Questo codice ( provalo ):

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());

stampe

woof
meom

alla console.

Usando typeof

typeof viene utilizzato quando è necessario distinguere tra tipi number , string , boolean e symbol . Altre costanti di stringa non verranno errate, ma non verranno utilizzate per restringere i tipi.

A differenza di instanceof , typeof funzionerà con una variabile di qualsiasi tipo. Nell'esempio seguente, foo potrebbe essere digitato come number | string senza problema.

Questo codice ( provalo ):

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");

stampe

123
not a number: foo

Digitare funzioni di protezione

Puoi dichiarare le funzioni che fungono da guardie dei tipi utilizzando qualsiasi logica desideri.

Prendono la forma:

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

Se la funzione restituisce true, TypeScript restringerà il tipo a DesiredType in qualsiasi blocco protetto da una chiamata alla funzione.

Ad esempio ( provalo ):

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]]"

Il predicato del tipo di funzione di una guardia (il foo is Bar nella posizione del tipo restituito dalla funzione) viene utilizzato in fase di compilazione per restringere i tipi, il corpo della funzione viene utilizzato in fase di runtime. Il predicato di tipo e la funzione devono essere d'accordo, altrimenti il ​​tuo codice non funzionerà.

Le funzioni di protezione del tipo non devono usare typeof o instanceof , possono usare una logica più complicata.

Ad esempio, questo codice determina se hai un oggetto jQuery controllando la sua stringa di versione.

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);
    }
}