Compruebe el tipo de objeto en tiempo de ejecución en TypeScript

1. Tipos principales en TypeScript
2. Compruebe el tipo de clase en tiempo de ejecución en TypeScript
3. Compruebe el tipo de interfaz en tiempo de ejecución en TypeScript

Este artículo explica cómo verificar el tipo de objeto en tiempo de ejecución en TypeScript.

Tipos principales en TypeScript

TypeScript es un lenguaje fuertemente tipado. Por lo tanto, comprueba los tipos en tiempo de compilación, lo que reduce los errores de tiempo de ejecución.

En TypeScript, tenemos varios tipos principales, como se muestra a continuación.

• Tipos primitivos como cadena, número y booleano
• Tipos de clase personalizados
• Tipos de interfaz
• Tipos de unión
• Tipo de alias

Compruebe el tipo de clase en tiempo de ejecución en TypeScript

TypeScript es compatible con la palabra clave class de EcmaScript 6. Se puede usar para escribir su código de forma orientada a objetos.

Vamos a crear la clase Engineer.

class Engineer {
}

Agreguemos un método ya que esta clase no contiene propiedades ni comportamientos.

class Engineer {
    visitSite(): void {
        console.log("This is the Engineer class");
    }
}

Digamos que tenemos otra clase, Doctor, como se muestra a continuación.

class Doctor {
    visitWard(): void {
        console.log("This is the Doctor class");
    }
}

El Engineer y el Doctor son dos tipos definidos por el usuario. En algunos escenarios, debemos verificar si un tipo de objeto existente pertenece a la clase Engineer o Doctor.

Esto es bastante sencillo con el operador instanceof de TypeScript.

Use el operador instanceof para verificar el tipo de clase

Comprueba si el objeto dado es una instancia de una clase de TypeScript o un constructor. Considera la herencia multinivel para verificar si la clase relevante aparece en un nivel diferente.

Si se encuentra una clase coincidente, devolverá true; de lo contrario, generará false.

Sintaxis:

my_object instanceof my_custom_class_type

Usemos este operador para diferenciar entre las clases Engineer y Doctor dentro de nuestra lógica de TypeScript.

Primero, crearemos una nueva función de verificación checkObjectType().

function checkObjectType(myObject) {
    if (myObject instanceof Engineer) {
        myObject.visitSite()
    }
    if (myObject instanceof Doctor) {
        myObject.visitWard()
    }
}

En la función de verificación anterior, verificamos la clase de myObject. Basándonos en el resultado, llamamos a los métodos de la clase a la que pertenecen visitSite() o visitWard().

Iniciemos objetos de ambas clases y pasemos el objeto al método checkObjectType.

let engineerObject: Engineer = new Engineer;
let doctorObject: Doctor = new Doctor;
checkObjectType(engineerObject);
checkObjectType(doctorObject);

Producción:

Como era de esperar, TypeScript identifica la clase correcta para cada objeto proporcionado.

Compruebe el tipo de interfaz en tiempo de ejecución en TypeScript

La instanceof se puede utilizar para comprobar si la instancia dada pertenece a una clase. Pero esto no funciona con los tipos de interfaz de TypeScript o los alias de tipo.

En tiempo de ejecución, todos estos tipos de interfaz desaparecen. Por lo tanto, el operador habitual de JavaScript typeof dará la salida como el object.

Definamos dos interfaces, Airplane y Car, como se muestra a continuación.

interface Airplane {
    hasWings() {
        console.log("2 wings");
    }
}

interface Car {
    hasWheels() {
        console.log("4 wheels");
    }
}

A continuación, crearemos una protección de tipo definida por el usuario de TypeScript para comprobar si el objeto dado pertenece al tipo Airplane o Car y limitar el objeto a un tipo compatible. Aquí, deberíamos usar el predicado de tipo como el tipo de retorno.

Sintaxis del predicado de tipo:

my_parameter_name is custom_type

El my_parameter_name debe ser el argumento actual pasado a la función. En este caso, el custom_type será el Airplane o Car.

Definamos los dos tipos de guardias:

function isAirplane(anyObject: any): anyObject is Airplane {
    return (anyObject as Airplane).hasWings() !=== undefined;
}

Verificamos que la forma del objeto sea equivalente a la forma de la interfaz comprobando si el método hasWings() está disponible para el objeto pasado anyObject. Luego, devolvemos el predicado de tipo que reduce el objeto al tipo Airplane.

Podemos implementar la función isCar() de manera similar.

function isCar(anyObject: any): anyObject is Car {
    return (anyObject as Car).hasWheels() !=== undefined;
}

Finalmente, podemos implementar la función testType() para probar el código.

let car: Car = {wheels: 4};
let flight: Airplane = {wings: 2};

function testType(obj: any) {
  if (isAirplane(obj)) {
    // 'obj' is narrowed to type 'Airplane'
    console.log("Airplane wings: "+ obj.wings);
  }
  else if (isCar(obj)) {
    // 'obj' is narrowed to type 'Car'
     console.log("Car wheels: "+ obj.wheels);
  }
}

testType(car);
testType(flight);

Producción:

Con la ayuda de protectores de tipos definidos por el usuario, podemos comprobar el tipo exacto de las interfaces en tiempo de ejecución.