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.

Practice

1. What does the instanceof operator check in TypeScript?

easy

A. If a variable is a primitive type

B. If an object is an instance of a specific class

C. If a function returns a boolean

D. If a type is an interface

Solution

1. Step 1: Understand the purpose of instanceof

   The instanceof operator checks whether an object was created from a particular class.

2. Step 2: Differentiate from other checks

   It does not check primitive types, function returns, or interfaces, only class instances.

3. Final Answer:

   If an object is an instance of a specific class -> Option B

4. Quick Check:

   instanceof checks class instance = A [OK]

Hint: Remember: instanceof works only with classes, not interfaces [OK]

Common Mistakes:

• Thinking instanceof works with interfaces
• Confusing instanceof with typeof
• Assuming instanceof checks primitive types

2. Which of the following is the correct syntax to check if obj is an instance of class Car?

easy

A. if (obj instanceof Car) { }

B. if (obj instance Car) { }

C. if (obj is Car) { }

D. if (obj type Car) { }

Solution

1. Step 1: Recall correct instanceof syntax

   The correct syntax uses the keyword instanceof between the object and the class name.

2. Step 2: Identify invalid options

   Options B, C, and D use incorrect keywords or missing syntax.

3. Final Answer:

   if (obj instanceof Car) { } -> Option A

4. Quick Check:

   Correct syntax uses instanceof keyword = A [OK]

Hint: Use 'instanceof' keyword exactly between object and class [OK]

Common Mistakes:

• Using 'is' or 'type' instead of 'instanceof'
• Omitting parentheses around condition
• Writing 'instance' instead of 'instanceof'

3. What will be the output of this code?

class Dog { bark() { return 'woof'; } }
class Cat { meow() { return 'meow'; } }
function speak(animal: Dog | Cat) {
  if (animal instanceof Dog) {
    return animal.bark();
  } else {
    return animal.meow();
  }
}
console.log(speak(new Cat()));

medium

A. 'woof'

B. TypeError at runtime

C. 'meow'

D. undefined

Solution

1. Step 1: Identify the object passed

   The function speak is called with new Cat(), so animal is a Cat instance.

2. Step 2: Check the instanceof condition

   The condition animal instanceof Dog is false, so the else block runs, returning animal.meow().

3. Final Answer:

   'meow' -> Option C

4. Quick Check:

   Cat instance triggers else block = D [OK]

Hint: Trace instanceof condition to pick correct method call [OK]

Common Mistakes:

• Assuming instanceof works with interfaces
• Confusing which method runs for which class
• Expecting 'woof' when passing Cat instance

4. Identify the error in this code snippet:

interface Bird { fly(): void; }
class Eagle implements Bird { fly() { console.log('Flying'); } }
function check(bird: Bird) {
  if (bird instanceof Eagle) {
    bird.fly();
  }
}

medium

A. No error, code is correct

B. Missing return type in fly() method

C. Cannot use instanceof with interfaces

D. Eagle class must be abstract

Solution

1. Step 1: Understand instanceof usage

   The instanceof operator is used with the class Eagle, which is valid even though bird is typed as the interface Bird.

2. Step 2: Verify no errors

   There are no syntax errors, type mismatches, or runtime issues. TypeScript compiles this code and narrows bird to Eagle inside the if block.

3. Final Answer:

   No error, code is correct -> Option A

4. Quick Check:

   instanceof with class on interface-typed param works = D [OK]

Hint: Remember: instanceof works with classes even on interface-typed variables [OK]

Common Mistakes:

• Thinking instanceof can't be used on interface-typed variables
• Confusing instanceof with direct interface checks
• Thinking implementing class must be abstract

5. Given these classes:

class Animal { name: string; constructor(name: string) { this.name = name; } }
class Fish extends Animal { swim() { return 'swimming'; } }
class Bird extends Animal { fly() { return 'flying'; } }

Write a function move that takes animal: Animal and returns 'swimming' if it's a Fish, 'flying' if it's a Bird, or 'unknown' otherwise. Which implementation is correct?

hard

A. function move(animal: Animal) { if (animal instanceof Animal) return 'unknown'; else if (animal instanceof Fish) return animal.swim(); else return animal.fly(); }

B. function move(animal: Animal) { if (animal instanceof Fish) return 'flying'; else if (animal instanceof Bird) return 'swimming'; else return 'unknown'; }

C. function move(animal: Animal) { if (animal instanceof Fish) return animal.fly(); else if (animal instanceof Bird) return animal.swim(); else return 'unknown'; }

D. function move(animal: Animal) { if (animal instanceof Fish) return animal.swim(); else if (animal instanceof Bird) return animal.fly(); else return 'unknown'; }

Solution

1. Step 1: Check instanceof order and method calls

   The function must check if animal is a Fish or Bird using instanceof and call the correct method.

2. Step 2: Validate each option

   function move(animal: Animal) { if (animal instanceof Fish) return animal.swim(); else if (animal instanceof Bird) return animal.fly(); else return 'unknown'; } correctly checks Fish first, calls swim(), then Bird with fly(), else returns 'unknown'. function move(animal: Animal) { if (animal instanceof Animal) return 'unknown'; else if (animal instanceof Fish) return animal.swim(); else return animal.fly(); } wrongly checks Animal first, which always matches. function move(animal: Animal) { if (animal instanceof Fish) return animal.fly(); else if (animal instanceof Bird) return animal.swim(); else return 'unknown'; } swaps methods incorrectly. function move(animal: Animal) { if (animal instanceof Fish) return 'flying'; else if (animal instanceof Bird) return 'swimming'; else return 'unknown'; } returns incorrect strings directly without calling methods.

3. Final Answer:

   function move(animal: Animal) { if (animal instanceof Fish) return animal.swim(); else if (animal instanceof Bird) return animal.fly(); else return 'unknown'; } -> Option D

4. Quick Check:

   Correct instanceof checks and method calls = B [OK]

Hint: Check instanceof order and call matching methods [OK]

Common Mistakes:

• Checking base class first, blocking subclass checks
• Calling wrong methods for classes
• Returning strings instead of calling methods