Why instanceof fails on interfaces in Typescript - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why does instanceof fail with interfaces in TypeScript?

Consider the following TypeScript code snippet:

interface Animal { name: string; }
class Dog implements Animal { name: string; constructor(name: string) { this.name = name; } }
const pet: Animal = new Dog('Buddy');
console.log(pet instanceof Animal);

What will be the output and why?

A TypeError, because pet is not a class instance

B false, because interfaces do not exist at runtime and instanceof checks the prototype chain

C SyntaxError, because instanceof cannot be used with interfaces

D true, because pet is an instance of a class that implements Animal

💡 Hint

Think about what instanceof checks at runtime and what interfaces represent in TypeScript.

The instanceof operator checks if an object has a certain constructor in its prototype chain at runtime. Interfaces in TypeScript are only used at compile time for type checking and do not exist in the generated JavaScript code. Therefore, instanceof cannot be used with interfaces and will always return false.

❓ Predict Output

intermediate

Output of instanceof with class and interface

What is the output of this TypeScript code?

interface Vehicle { wheels: number; }
class Car implements Vehicle { wheels = 4; }
const myCar = new Car();
console.log(myCar instanceof Car);
console.log(myCar instanceof Vehicle);

A

true
false

B

true
true

C

false
false

D

false
true

💡 Hint

Remember that interfaces do not exist at runtime.

myCar instanceof Car returns true because myCar is created from the Car class. However, myCar instanceof Vehicle returns false because Vehicle is an interface and does not exist at runtime.

🔧 Debug

advanced

Why does this instanceof check always fail?

Look at this TypeScript code:

interface Shape { area(): number; }
class Circle implements Shape {
  radius: number;
  constructor(radius: number) { this.radius = radius; }
  area() { return Math.PI * this.radius * this.radius; }
}
const shape: Shape = new Circle(5);
if (shape instanceof Shape) {
  console.log('It is a Shape');
} else {
  console.log('Not a Shape');
}

Why does it always print 'Not a Shape'?

A Because Shape is an interface and does not exist at runtime, so instanceof always fails

B Because Circle does not extend Shape class, so instanceof returns false

C Because area method is missing in the object

D Because shape is not an object

💡 Hint

Think about what instanceof checks and what interfaces represent.

instanceof checks the prototype chain for a constructor function. Interfaces are only a compile-time construct and do not exist in the JavaScript output, so instanceof Shape always returns false.

📝 Syntax

advanced

Which code snippet causes a runtime error due to instanceof misuse?

Which of the following TypeScript code snippets will cause a runtime error when executed?

A

interface Person { name: string; }
const p: Person = { name: 'Alice' };
console.log(p instanceof Person);

B

class Person { name: string; constructor(name: string) { this.name = name; } }
const p = new Person('Alice');
console.log(p instanceof Person);

C

const p = { name: 'Alice' };
console.log(p instanceof Object);

D

const p = null;
console.log(p instanceof Object);

💡 Hint

Consider what values can be used with instanceof without causing errors.

Using instanceof with null causes a runtime TypeError because null is not an object and cannot have a prototype chain.

🚀 Application

expert

How to check if an object implements an interface at runtime?

Since instanceof does not work with interfaces in TypeScript, which approach below correctly checks if an object implements the Logger interface at runtime?

interface Logger { log(message: string): void; }

A Use <code>typeof obj === 'Logger'</code> to check the type

B Use <code>obj instanceof Logger</code> to check if it implements Logger

C Use <code>if ('log' in obj && typeof obj.log === 'function')</code> to check for the method

D Use <code>obj.constructor.name === 'Logger'</code> to check the class name

💡 Hint

Interfaces do not exist at runtime, so you must check properties manually.

Because interfaces are erased during compilation, you cannot use instanceof or typeof to check for them. Instead, checking if the object has the required method with the correct type is the common runtime approach.