Vérifier le type d'objet lors de l'exécution dans TypeScript

1. Types principaux dans TypeScript
2. Vérifier le type de classe lors de l’exécution dans TypeScript
3. Vérifier le type d’interface lors de l’exécution dans TypeScript

Cet article explique comment vérifier le type d’objet lors de l’exécution dans TypeScript.

Types principaux dans TypeScript

TypeScript est un langage fortement typé. Par conséquent, il vérifie les types au moment de la compilation, ce qui réduit les erreurs d’exécution.

Dans TypeScript, nous avons plusieurs types principaux, comme indiqué ci-dessous.

• Types primitifs tels que chaîne, nombre et booléen
• Types de cours personnalisés
• Types d’interfaces
• Types d’union
• Tapez les alias

Vérifier le type de classe lors de l’exécution dans TypeScript

TypeScript prend en charge le mot-clé class de l’EcmaScript 6. Il peut être utilisé pour écrire votre code de manière POO.

Créons la classe Engineer.

class Engineer {
}

Ajoutons une méthode puisque cette classe ne contient aucune propriété ou comportement.

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

Disons que nous avons une autre classe, Doctor, comme indiqué ci-dessous.

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

Engineer et Doctor sont deux types définis par l’utilisateur. Dans certains scénarios, il faut vérifier si un type d’objet existant appartient à la classe Engineer ou Doctor.

C’est assez simple avec l’opérateur TypeScript instanceof.

Utilisez l’opérateur instanceof pour vérifier le type de classe

Il vérifie si l’objet donné est une instance d’une classe TypeScript ou un constructeur. Il considère l’héritage multi-niveaux pour vérifier si la classe concernée apparaît à un niveau différent.

Si une classe correspondante est trouvée, elle retournera true ; sinon, il affichera false.

Syntaxe:

my_object instanceof my_custom_class_type

Utilisons cet opérateur pour différencier les classes Engineer et Doctor dans notre logique TypeScript.

Tout d’abord, nous allons créer une nouvelle fonction de vérification checkObjectType().

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

Dans la fonction de vérification ci-dessus, nous vérifions la classe de myObject. En fonction du résultat, nous appelons les méthodes de classe appartenant visitSite() ou visitWard().

Initions les objets des deux classes et passons l’objet à la méthode checkObjectType.

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

Production:

Comme prévu, TypeScript identifie la classe correcte pour chaque objet fourni.

Vérifier le type d’interface lors de l’exécution dans TypeScript

Le instanceof peut être utilisé pour vérifier si l’instance donnée appartient à une classe. Mais cela ne fonctionne pas avec les types d’interface TypeScript ou les alias de type.

Lors de l’exécution, tous ces types d’interface ont disparu. Par conséquent, l’opérateur JavaScript habituel typeof donnera comme résultat un object.

Définissons deux interfaces, Airplane et Car, comme indiqué ci-dessous.

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

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

Ensuite, nous allons créer un type de garde TypeScript défini par l’utilisateur pour vérifier si l’objet donné appartient au type Airplane ou Car et restreindre l’objet à un type compatible. Ici, nous devrions utiliser le prédicat de type comme type de retour.

Syntaxe du prédicat de type :

my_parameter_name is custom_type

Le my_parameter_name doit être l’argument courant passé à la fonction. Dans ce cas, le custom_type sera le Airplane ou la Car.

Définissons les deux gardes de type :

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

On vérifie que la forme de l’objet est équivalente à la forme de l’interface en vérifiant si la méthode hasWings() est disponible pour l’objet passé anyObject. Ensuite, nous renvoyons le prédicat de type qui restreint l’objet au type Airplane.

Nous pouvons implémenter la fonction isCar() de la même manière.

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

Enfin, nous pouvons implémenter la fonction testType() pour tester le code.

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

Production:

À l’aide de protections de type définies par l’utilisateur, nous pouvons vérifier le type exact des interfaces au moment de l’exécution.