TypeScript
Zdefiniowane przez użytkownika zabezpieczenia typu

Składnia

• typeof x === „nazwa typu”
• x instanceof TypeName
• function (foo: any): foo to TypeName {/ * kod zwracający wartość logiczną * /}

Uwagi

Korzystanie z instanceof

instanceof wymaga, aby zmienna była any typu.

Ten kod ( spróbuj ):

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

odciski

woof
meom

do konsoli.

Korzystanie z typeof

typeof jest używany, gdy trzeba rozróżnić number typu, string , wartość boolean i symbol . Inne stałe ciągów nie będą błędne, ale nie będą również używane do zawężania typów.

W przeciwieństwie do instanceof , typeof będzie działać ze zmienną dowolnego typu. W poniższym przykładzie foo można wpisać jako number | string bez problemu.

Ten kod ( spróbuj ):

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

odciski

123
not a number: foo

Wpisz funkcje ochrony

Możesz zadeklarować funkcje, które pełnią rolę strażników typów, używając dowolnej logiki.

Przyjmują formę:

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

Jeśli funkcja zwróci true, TypeScript DesiredType typ do DesiredType w dowolnym bloku strzeżonym przez wywołanie funkcji.

Na przykład ( spróbuj ):

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

Predykat typu funkcji wartownika ( foo is Bar w pozycji typu powrotu funkcji) jest używany w czasie kompilacji do wąskich typów, ciało funkcji jest używane w czasie wykonywania. Predykat typu i funkcja muszą się zgadzać, inaczej kod nie będzie działał.

Funkcje ochrony typów nie muszą używać typu typeof ani instanceof , mogą korzystać z bardziej skomplikowanej logiki.

Na przykład ten kod określa, czy masz obiekt jQuery, sprawdzając jego ciąg wersji.

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