Not What It Is, But Where It Belongs: Rethinking instanceof in JavaScript

There’s a quiet assumption we often carry when we write code:

That objects know what they are.

That somewhere inside them is a label—

a definitive identity—that tells us:

“This is an Array”

“This is a Person”

“This is a Date”

And when we reach for instanceof, it feels like we’re asking that question directly.

But JavaScript doesn’t answer it the way we expect.

Because it’s not asking what something is.

It’s asking something else entirely.

A Question About Belonging

When you write:

obj instanceof Constructor

It looks like a type check.

But it’s not checking identity.

It’s checking relationship.

More specifically:

Does this object belong to the prototype chain of that constructor?

This is not about creation.

It’s about connection.

Following the Chain

Every object in JavaScript exists within a chain.

Not a hierarchy in the traditional sense—

but a linked structure of prototypes.

An object points to a prototype.

That prototype points to another.

And so on, until the chain ends.

When instanceof runs, it walks this chain.

Step by step.

Looking for one specific thing:

The prototype of the constructor you provided.

If it finds it, the answer is true.

If it doesn’t, the answer is false.

That’s all.

The Illusion of Origin

It’s tempting to think:

“If an object was created using a constructor, then it must be an instance of it.”

And often, that’s true.

But only because the constructor sets up the prototype chain that way.

The connection feels like origin—

but it’s really just structure.

And structure can be changed.

When Expectations Break

Because this system is based on prototypes, not creation, it allows for something unusual.

You can take an object—

one that has nothing to do with a constructor—

and link it into that constructor’s prototype chain.

And suddenly, instanceof will return true.

Not because the object was created differently.

But because its position in the chain has changed.

The result feels incorrect.

But the mechanism is working exactly as designed.

Identity Is Not Enough

This reveals something deeper:

JavaScript does not define objects by where they came from.

It defines them by how they are connected.

Two objects can look identical.

Behave identically.

Hold the same values.

And yet, instanceof may treat them differently—

because their prototype chains are not the same.

Not structurally similar.

Exactly the same.

A Boundary You Don’t Always See

This becomes even more apparent when you cross environments.

An array created in one context—

say, an iframe—

is not considered an instance of Array in another.

Even though everything about it appears identical.

Because under the surface:

They do not share the same prototype reference.

The structure matches.

The identity does not.

And for instanceof, identity is everything.

When the Rules Can Be Rewritten

There’s an even stranger possibility.

You can redefine how instanceof behaves.

Override its logic entirely.

Make it return true or false based on conditions you control.

At that point, the question:

“Is this an instance of that?”

Stops being objective.

And becomes something you define.

Which tells you something important:

Even this mechanism is not absolute.

It is flexible.

By design.

A Shift in Understanding

Once you see how instanceof works, your thinking begins to change.

You stop asking:

“What is this object?”

And start asking:

“What is this object connected to?”

That shift may seem small—

but it aligns your thinking with how JavaScript actually operates.

Not through rigid identity—

but through relationships.

The Shape Beneath the Surface

In many languages, types are declarations.

In JavaScript, they are emergent.

They arise from how objects are linked.

From how prototypes are arranged.

From how structure is composed.

instanceof is simply a way of observing that structure.

Not defining it.

A Final Reflection

instanceof doesn’t tell you what something is.

It tells you where it lives.

Which chain it belongs to.

Which structure it participates in.

Which relationships define it.

And once you understand that,

you begin to see objects differently.

Not as isolated entities—

but as points within a connected system.

Defined not by origin—

but by association.

And in that system, identity is not declared.

It is inherited.