TypeScript
Tipo de guardias definidos por el usuario

Sintaxis

• typeof x === "nombre de tipo"
• x instanceof TypeName
• función (foo: any): foo es TypeName {/ * código que devuelve booleano * /}

Observaciones

Usando instanceof

instanceof requiere que la variable sea de tipo any .

Este código ( pruébalo ):

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

huellas dactilares

woof
meom

a la consola.

Utilizando typeof

typeof se usa cuando necesitas distinguir entre tipos number , string , boolean y symbol . Otras constantes de cadena no generarán errores, pero tampoco se utilizarán para restringir tipos.

A diferencia de instanceof , typeof trabajará con una variable de cualquier tipo. En el siguiente ejemplo, foo podría escribirse como number | string sin problema.

Este código ( pruébalo ):

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

huellas dactilares

123
not a number: foo

Funciones de protección de tipo

Puedes declarar funciones que sirven como guardias de tipo usando cualquier lógica que desees.

Toman la forma:

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

Si la función devuelve true, TypeScript restringirá el tipo a DesiredType en cualquier bloque protegido por una llamada a la función.

Por ejemplo ( pruébalo ):

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

Se utiliza un predicado de tipo de función de guardia (el foo is Bar en la posición de tipo de retorno de función) en tiempo de compilación para tipos más estrechos, el cuerpo de función se usa en tiempo de ejecución. El tipo de predicado y la función deben coincidir, o su código no funcionará.

Las funciones de protección de tipo no tienen que usar typeof o instanceof , pueden usar una lógica más complicada.

Por ejemplo, este código determina si tienes un objeto jQuery al verificar su cadena de versión.

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