Skip to content Skip to footer

Understanding the instanceof Operator in JavaScript

Hey JavaScript enthusiasts! Today, we’re diving into the instanceof operator and how it can be a real game-changer when you’re trying to figure out the type of an object. This operator might seem straightforward, but trust me, it’s got some nuances that are worth exploring.

What’s the instanceof Operator All About?

In the wild world of JavaScript, the instanceof operator is a binary operator that tests whether the prototype property of a constructor appears anywhere in the prototype chain of an object. In layman’s terms, it checks if an object is an instance of a specific class or constructor function.

Here’s the basic syntax:

object instanceof constructor

If the object inherits from the constructor’s prototype, you’ll get a true — otherwise, it’s a false.

A Simple Example to Kick Things Off

Let’s start with something simple. Imagine you’ve got a couple of constructors and you’re itching to know if an object is part of their lineage. Check this out:

function Roadster() {}
function Truck() {}

let cybertruck = new Truck();

console.log(cybertruck instanceof Truck); // true
console.log(cybertruck instanceof Roadster); // false

In this case, cybertruck is indeed an instance of Truck, but it has no connection to Roadster. Pretty straightforward, right?

When instanceof Gets Tricky

Now, let’s not get too comfy, because instanceof can get a bit tricky. For instance, when you’re working with different contexts, like iframes or different Node.js modules, each context has its own global scope, which means constructors from one context are not the same as those from another.

Here’s a snippet to ponder:

let iframe = document.createElement('iframe');
let FrameArray = iframe.contentWindow.Array;
let array = new FrameArray();

console.log(array instanceof Array); // false
console.log(array instanceof FrameArray); // true

This might seem bonkers, but it’s because array is actually an instance of the Array from the iframe’s context, not the main page’s context.

Prototypes and instanceof

The real power of instanceof lies in its ability to play nice with prototypes. Since JavaScript is all about those prototypes, this operator checks the entire prototype chain, which can be super useful.

function Vehicle() {}
function Car() {}

Car.prototype = Object.create(Vehicle.prototype);

let myCar = new Car();

console.log(myCar instanceof Car); // true
console.log(myCar instanceof Vehicle); // true

Here, myCar is an instance of both Car and Vehicle because Car‘s prototype is in the prototype chain of Vehicle.

Custom instanceof Checks

But wait, there’s more! You can customize the behavior of instanceof by tweaking the Symbol.hasInstance method. This is like giving instanceof a new pair of glasses to see the world differently.

class CoolArray {
  static [Symbol.hasInstance](instance) {
    return Array.isArray(instance) && instance.length > 0;

console.log([] instanceof CoolArray); // false
console.log([1, 2, 3] instanceof CoolArray); // true

In this chunk of code, any non-empty array will be considered an instance of CoolArray. Empty ones? Not so much.

instanceof in Different Frameworks

Alright, let’s get our hands dirty with some framework action. Whether you’re a React.js virtuoso or an Angular aficionado, instanceof has got your back.

React.js and instanceof

React.js is all about components, and sometimes you need to know if a component is of a certain class. Here’s how instanceof can come into play:

import React from 'react';

class MyComponent extends React.Component {}

let element = new MyComponent();

console.log(element instanceof React.Component); // true

In this React snippet, element is indeed an instance of React.Component.

Angular and instanceof

Moving on to Angular, services and dependency injection are the name of the game. You can use instanceof to ensure that a service is an instance of a particular class:

import { Injectable } from '@angular/core';

  providedIn: 'root',
export class MyService {}

let myServiceInstance = new MyService();

console.log(myServiceInstance instanceof MyService); // true

Here, myServiceInstance is confirmed to be an instance of MyService, which is especially handy when dealing with Angular’s DI system.

The instanceof Wrap-Up (For Now)

So far, we’ve seen that instanceof is more than just a simple check — it’s a flexible and powerful tool in your JavaScript toolkit. We’ve covered the basics, dipped our toes into some tricky scenarios, and seen how it plays out in different frameworks.

Stay tuned for the second half of this article where we’ll tackle more advanced use cases, explore instanceof with built-in objects, and throw in some pro tips to keep you coding like a boss. Keep those keyboards clacking and those minds open — more instanceof wisdom is on its way!

Welcome back, fellow code wranglers! We’ve already saddled up and taken a ride through the basics of the instanceof operator in JavaScript. Now, it’s time to push beyond the beginner’s trail and explore the wilder side of instanceof. Buckle up, because we’re about to kick things up a notch!

instanceof with Built-in Objects

JavaScript comes with a corral full of built-in constructors—Object, Function, Array, you name it. The instanceof operator can help you identify these types as well.

let func = function() {};
let obj = {};
let arr = [];

console.log(func instanceof Function); // true
console.log(obj instanceof Object); // true
console.log(arr instanceof Array); // true

These checks are particularly useful when you’re dealing with API data and need to confirm data types before processing.

The Edge Cases of instanceof

Now, let’s talk about the edge cases. Because JavaScript is a dynamic language, there are scenarios where instanceof might not behave as you’d expect.

Primitive Values

First off, primitive values like strings, numbers, and booleans are not objects, so instanceof can be a bit misleading here.

let name = "Wes Bos";

console.log(name instanceof String); // false

Even though name is a string, it’s not an instance of the String object. Keep this in mind to avoid any cowboy coding mishaps.

Null and Undefined

Next up, null and undefined. These two special values will always return false when used with instanceof, because, well, they’re not instances of anything.

let nothing = null;

console.log(nothing instanceof Object); // false

Functions and instanceof

Functions in JavaScript are first-class objects, which means they can be treated like any other object. They’re also instances of Function.

function sayHowdy() {}

console.log(sayHowdy instanceof Function); // true
console.log(sayHowdy instanceof Object); // true

Yep, sayHowdy is an instance of both Function and Object, because in JavaScript, functions are objects too.

Pro Tips for Using instanceof

Alright, let’s round up some pro tips to make sure you’re getting the most out of instanceof.

Checking the Existence of Methods

One slick use of instanceof is to check if an object has a certain method. This can be a lifesaver when you’re dealing with polymorphism.

class Animal {
  speak() {
    console.log("Some generic animal sound!");

class Dog extends Animal {
  speak() {
    console.log("Woof woof!");

let buddy = new Dog();

if (buddy instanceof Animal) {
  buddy.speak(); // Woof woof!

In this example, we’re confident that buddy can speak() because it’s an instance of Animal.

Using instanceof with Custom Classes

When you’re working with custom classes, instanceof can help you maintain type safety and ensure that your instances are what you expect them to be.

class Component {}
class Button extends Component {}

let myButton = new Button();

console.log(myButton instanceof Component); // true
console.log(myButton instanceof Button); // true

This is super handy in complex applications where type checking can prevent unexpected bugs.

The Limitations of instanceof

Remember, instanceof is not a silver bullet. It checks the prototype chain, which means any object with the correct prototype in its chain will return true.

let fakeDate = { __proto__: Date.prototype };

console.log(fakeDate instanceof Date); // true

Here, fakeDate isn’t really a Date, but because we’ve manually set its prototype, instanceof is fooled into thinking it is.


The instanceof operator in JavaScript is like a trusty lasso—it’s great for wrangling types and checking your objects. But just like any tool in the wild west of coding, you’ve got to know its quirks and use it wisely.

Remember, instanceof is all about prototypes, it’s not infallible, and there are cases where it might not work as you expect. But with the tips and tricks we’ve covered, you’ll be well-equipped to use instanceof with confidence.

Keep on coding, partner, and may your objects always be of the right instance! 🤠👨‍💻