instanceof in TypeScript is a type guard that narrows object types based on class membership, enabling safer and more expressive polymorphic code. 1. It checks if an object is an instance of a class and informs the compiler to narrow the type within conditional blocks, eliminating the need for type assertions. 2. It works effectively with class hierarchies, allowing access to subclass-specific methods after type narrowing, such as calling honk() on Car or takeOff() on Plane when derived from a shared base class like Vehicle. 3. Limitations include incompatibility with interfaces and object literals, failure across execution contexts like iframes, and unsuitability for primitive wrapper objects. 4. Best practices include using instanceof with class inheritance, combining it with discriminated unions for enhanced type safety, avoiding it for plain objects, and exercising caution in cross-context environments. 5. A hybrid approach using instanceof with tagged unions, such as distinguishing SuccessResponse from ErrorResponse, ensures both runtime checks and compile-time type safety. When applied appropriately, instanceof enhances code maintainability and robustness in polymorphic scenarios.

Polymorphism in TypeScript isn’t just about inheritance or interfaces—it’s about writing flexible, safe code that adapts to different types at runtime. One of the most practical tools for achieving this is the instanceof type guard. It helps you narrow down object types in a way the compiler understands, making your code both safer and more expressive.

Let’s break down how instanceof works as a type operator and how you can use it effectively in real-world scenarios.

What instanceof Does in TypeScript

At its core, instanceof checks whether an object is an instance of a particular class. But in TypeScript, it does more than just return a boolean—it acts as a type guard. When used in a conditional, it tells the compiler to narrow the type of a variable within that block.

class Dog {
  bark() {
    console.log("Woof!");
  }
}

class Cat {
  meow() {
    console.log("Meow!");
  }
}

function makeSound(animal: Dog | Cat) {
  if (animal instanceof Dog) {
    animal.bark(); // ? Type is narrowed to Dog
  } else {
    animal.meow(); // ? Type is narrowed to Cat
  }
}

Here, TypeScript knows that inside the if block, animal must be a Dog. No type assertions needed.

Using instanceof with Custom Classes and Inheritance

Where instanceof really shines is in polymorphic hierarchies. Suppose you have a base class and several derived classes:

abstract class Vehicle {
  abstract move(): void;
}

class Car extends Vehicle {
  move() {
    console.log("Car driving on roads");
  }

  honk() {
    console.log("Beep!");
  }
}

class Plane extends Vehicle {
  move() {
    console.log("Plane flying in the sky");
  }

  takeOff() {
    console.log("Liftoff!");
  }
}

Now, when handling a Vehicle, you can use instanceof to safely access subclass-specific methods:

function operate(vehicle: Vehicle) {
  vehicle.move(); // ? Safe: all vehicles have move()

  if (vehicle instanceof Car) {
    vehicle.honk(); // ? Only available on Car
  } else if (vehicle instanceof Plane) {
    vehicle.takeOff(); // ? Only available on Plane
  }
}

This pattern is common in event handling, plugin systems, or any system where you process objects of varying but related types.

Limitations and Gotchas

While instanceof is powerful, it has some important caveats:

• Only works with classes, not interfaces or object literals.

  interface Bird {
    fly(): void;
  }
  
  const bird = { fly: () => console.log("Flying") };
  
  // ? Won't work — interfaces don't exist at runtime
  if (bird instanceof Bird) { ... }

• Breaks across execution contexts (e.g., iframes). Because each context has its own global object, instanceof may fail even if the class looks identical.

• Not suitable for primitive wrappers like String, Number, etc., unless you're dealing with actual wrapper objects (which is rare).

Best Practices for Using instanceof

To get the most out of instanceof while avoiding pitfalls:

• ? Use it when working with class hierarchies and inheritance.
• ? Combine it with discriminated unions for more robust type safety when possible.
• ? Avoid it for type-checking plain objects—use literal type guards or in checks instead.
• ? Be cautious in libraries that may be used across iframe boundaries.

For example, a hybrid approach with a discriminated union:

type ApiResponse = SuccessResponse | ErrorResponse;

class SuccessResponse {
  constructor(public data: string) {}
}

class ErrorResponse {
  constructor(public error: string) {}
}

function handleResponse(res: SuccessResponse | ErrorResponse) {
  if (res instanceof SuccessResponse) {
    console.log("Success:", res.data);
  } else {
    console.log("Error:", res.error);
  }
}

This gives you both runtime checking and compile-time safety.

Summary

instanceof is a reliable, built-in way to perform type narrowing when dealing with class instances in TypeScript. It supports polymorphic behavior by letting you write logic that adapts based on the actual runtime type, all while keeping the compiler informed.

It’s not a one-size-fits-all solution—stick to classes, watch out for cross-context issues, and consider alternatives like tagged unions for non-class types.

Used wisely, instanceof makes your polymorphic code cleaner, safer, and easier to maintain.

The above is the detailed content of Mastering Polymorphism: A Practical Guide to the `instanceof` Type Operator. For more information, please follow other related articles on the PHP Chinese website!