instanceof函数参数在Typescript / Angular中返回false

Question

I'm trying to find out how to get the type of an Object if it was passed as a parameter in my function.

For example you have following code

getTypeOfAnimal(animal){
   console.log(animal instanceof Cat)
   console.log(animal instanceof Bear)
}

animal could be either an instanceof a Cat or a Bear. The animal passed in from my form always returns false (also if the Object's structure seems to match one of a Cat or a Bear).

Is there a way to get the type properly?

Answer 1

The root of the problem is this line

also if the Object's structure seems to match one of a Cat or a Bear

The object structure won't matter here. The instanceof checks whether the object was created using a constructor of Cat or Bear , eg new Cat() (and actually if both extend Animal then the instanceof Animal would be true for both).

Normally TypeScript uses duck typing to resolve whether the interface is matching the object structure and this is where the similar object structure could work. However instanceof is JavaScript (because is executed in the runtime), so there is no much more TypeScript can do there. That is why it does not work as you might have expected.

Answer 2

If you are dealing with classes in a hierarchy, you can use instanceof :

class Animal {
    name: string;
}

class Cat extends Animal {
    purrs: boolean;
}

class Bear extends Animal {
    growls: boolean;
}


const animal = new Cat();
console.log(animal instanceof Cat); // true
console.log(animal instanceof Bear); // false

When dealing with structural types that you want to narrow, you can use a custom type guard:

const structuralBear = {
    name: 'Paddington',
    growls: false
};

console.log(structuralBear instanceof Cat); // false
console.log(structuralBear instanceof Bear); // false

function isBeary(obj: any): obj is Bear {
    console.log(typeof obj.growls);
    return (typeof obj.name === 'string' && typeof obj.growls === 'boolean');
}

console.log(isBeary(structuralBear));

This works out if something is "beary" enough for your needs...

On the whole, though, beware of needing to know too much about types in this way. The main use case is to narrow a union type.