TypeScript
Door de gebruiker gedefinieerde Type Guards

Syntaxis

• typeof x === "typenaam"
• x exemplaar van TypeName
• functie (foo: any): foo is TypeName {/ * code terugkerende boolean * /}

Opmerkingen

Instanceof gebruiken

instanceof vereist dat de variabele van het type any .

Deze code ( probeer het ):

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

prints

woof
meom

naar de console.

Typeof gebruiken

typeof wordt gebruikt wanneer u onderscheid moet maken tussen typen number , string , boolean en symbol . Andere stringconstanten zullen geen fouten maken, maar zullen ook niet worden gebruikt om typen te verfijnen.

In tegenstelling tot instanceof , werkt typeof met een variabele van elk type. In het onderstaande voorbeeld kan foo worden getypt als number | string zonder probleem.

Deze code ( probeer het ):

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

prints

123
not a number: foo

Type bewakingsfuncties

U kunt functies die als typebewaking dienen te declareren met elke gewenste logica.

Ze hebben de vorm:

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

Als de functie true retourneert, zal TypeScript het type beperken tot DesiredType in elk blok dat wordt bewaakt door een aanroep van de functie.

Bijvoorbeeld ( probeer het ):

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

Het predicaat functietype van een bewaker (de foo is Bar in de positie van het functie-retourtype) wordt tijdens het compileren gebruikt om typen te verkleinen, het functielichaam wordt tijdens runtime gebruikt. Het predicaat en de functie van het type moeten overeenkomen, anders werkt uw code niet.

Type bewakingsfuncties hoeven geen typeof instanceof , ze kunnen meer gecompliceerde logica gebruiken.

Deze code bepaalt bijvoorbeeld of u een jQuery-object hebt door te controleren op de versiereeks.

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