instanceof type guards in Typescript - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of instanceof with class inheritance

What is the output of the following TypeScript code?

Typescript

class Animal {}
class Dog extends Animal {}

const pet = new Dog();

console.log(pet instanceof Dog);
console.log(pet instanceof Animal);

A false\nfalse

B true\nfalse

C false\ntrue

D true\ntrue

💡 Hint

Remember that instanceof checks the prototype chain.

The pet is an instance of Dog, so pet instanceof Dog is true. Since Dog extends Animal, pet instanceof Animal is also true.

❓ Predict Output

intermediate

instanceof with interface and class

Given the code below, what will be the output?

Typescript

interface Vehicle {}
class Car implements Vehicle {}

const myCar = new Car();

console.log(myCar instanceof Car);
// console.log(myCar instanceof Vehicle); // Uncommenting this line causes what?

A true\nfalse

B true\nCompile-time error

C true\nTypeError

D true\nSyntaxError

💡 Hint

Interfaces do not exist at runtime in TypeScript.

instanceof works only with classes and constructor functions at runtime. Since Vehicle is an interface, it is erased during compilation, so myCar instanceof Vehicle causes a compile-time error.

🔧 Debug

advanced

Why does this instanceof check fail?

Consider the following code. Why does the instanceof check return false even though the object is created from the class?

Typescript

class Person {}

const obj = { name: "Alice" };

console.log(obj instanceof Person);

A Because obj is a plain object, not created with Person constructor

B Because Person class is not exported

C Because instanceof only works with interfaces

D Because obj has no name property

💡 Hint

Think about how instanceof works with prototypes.

The instanceof operator checks if the object was created by the constructor or inherits from its prototype. Here, obj is a plain object literal, not created by Person, so it returns false.

🧠 Conceptual

advanced

Using instanceof in type guards with union types

Given the classes below, which option correctly narrows the type using instanceof in a function?

Typescript

class Cat { meow() { return "meow"; } }
class Bird { chirp() { return "chirp"; } }

type Pet = Cat | Bird;

function speak(pet: Pet) {
  if (/* condition here */) {
    return pet.meow();
  } else {
    return pet.chirp();
  }
}

A pet instanceof Cat

B pet instanceof Bird

C typeof pet === 'Cat'

D pet.constructor === 'Cat'

💡 Hint

Use instanceof to check class type at runtime.

instanceof checks if pet is an instance of Cat. This narrows the type so pet.meow() is valid. Other options are incorrect because typeof returns 'object' for classes and constructor is a function, not a string.

❓ Predict Output

expert

Output of instanceof with prototype manipulation

What is the output of this TypeScript code?

Typescript

class A {}
class B extends A {}

const b = new B();

Object.setPrototypeOf(b, A.prototype);

console.log(b instanceof B);
console.log(b instanceof A);

A true\ntrue

B false\nfalse

C false\ntrue

D true\nfalse

💡 Hint

Changing the prototype affects instanceof checks.

By setting b's prototype to A.prototype, b instanceof B becomes false because B.prototype is no longer in the prototype chain. However, b instanceof A is true because A.prototype is now the direct prototype.