TypeScript
Benutzerdefinierte Typenschutz

Syntax

• typeof x === "Typname"
• x Instanz von TypeName
• Funktion (foo: any): foo ist TypeName {/ * code und liefert boolesche Werte * /}

Bemerkungen

Instanceof verwenden

instanceof setzt instanceof , dass die Variable den Typ any .

Dieser Code ( probiere es ):

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

druckt

woof
meom

zur Konsole.

Mit typeof

typeof wird verwendet, wenn Sie zwischen den Typen number , string , boolean und symbol . Andere String-Konstanten werden nicht fehlerhaft sein, werden aber auch nicht zum Einschränken von Typen verwendet.

Im Gegensatz zu instanceof arbeitet typeof mit einer beliebigen Variable. Im folgenden Beispiel könnte foo als number | string eingegeben werden number | string ohne Ausgabe.

Dieser Code ( probiere es ):

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

druckt

123
not a number: foo

Typüberwachungsfunktionen

Sie können Funktionen, die als Typenwächter dienen, mit einer beliebigen Logik deklarieren.

Sie nehmen die Form an:

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

Wenn die Funktion true zurückgibt, wird der Typ von DesiredType in jedem Block, der von einem Aufruf der Funktion überwacht wird, auf DesiredType .

Zum Beispiel ( probiere es ):

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

Ein Prädikat für einen Funktionstyp eines Guard (das foo is Bar in der Funktion return type position) wird zur Kompilierzeit verwendet, um Typen einzuengen. Das Typ-Prädikat und die Funktion müssen übereinstimmen, sonst funktioniert Ihr Code nicht.

Type-Guard-Funktionen müssen nicht typeof oder instanceof , sie können eine kompliziertere Logik verwenden.

Dieser Code bestimmt beispielsweise, ob Sie ein jQuery-Objekt haben, indem Sie nach der Versionszeichenfolge suchen.

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