TypeScript
Användardefinierade typskydd

Syntax

• typof x === "typnamn"
• x instans av typnamn
• funktion (foo: valfri): foo är typnamn {/ * -kod som returnerar boolean * /}

Anmärkningar

Med användning av instans

instanceof kräver att variabeln är av vilken typ som any .

Den här koden ( prova ):

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

grafik

woof
meom

till konsolen.

Med typof

typeof används när du behöver skilja mellan olika typer number , string , boolean , och symbol . Andra strängkonstanter kommer inte att fel, men kommer inte att användas för att begränsa typer heller.

Till skillnad från instanceof , typeof med en variabel av vilken typ som helst. I exemplet nedan kan foo skrivas som number | string utan problem.

Den här koden ( prova ):

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

grafik

123
not a number: foo

Skriv skyddsfunktioner

Du kan förklara funktioner som fungerar som typskydd med vilken logik du vill ha.

De tar formen:

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

Om funktionen returnerar sant kommer TypeScript att begränsa typen till DesiredType i alla block som skyddas av ett samtal till funktionen.

Till exempel ( prova det ):

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

Ett skydds funktionstyppredikat ( foo is Bar i positionen för funktionens returtyp) används vid sammanställningstiden för att smala typer, funktionskroppen används vid körning. Typpredikatet och funktionen måste vara överens, annars kommer din kod inte att fungera.

Typskyddsfunktioner behöver inte använda typeof eller instanceof , de kan använda mer komplicerad logik.

Till exempel bestämmer den här koden om du har ett jQuery-objekt genom att kontrollera om det är versionsträng.

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