How does the JavaScript `instanceof` operator decide its answer, and what exactly does it compare?

## The operator is a chain search, not a label check The most common wrong mental model is that `instanceof` asks "was this object made by this function?" It does not. It asks a purely structural question: *is the object currently referenced by `F.prototype` somewhere in `x`'s prototype chain?* Both halves of that sentence matter — it reads `F.prototype` now, and it compares by object identity, not by name or shape. ```js function A() {} const a = new A(); let p = Object.getPrototypeOf(a); while (p !== null) { if (p === A.prototype) console.log('found it'); p = Object.getPrototypeOf(p); } ``` That loop is essentially the whole operator. ## The spec path Evaluating `x instanceof F` runs roughly these steps: 1. If `F` is not an object, throw a `TypeError`. 2. Look up `F[Symbol.hasInstance]`. If it is not `undefined` or `null`, call it with `x` and coerce the result to a boolean. Ordinary functions inherit `Function.prototype[Symbol.hasInstance]`, so this branch is almost always taken and simply performs step 3. 3. Otherwise (a callable without that method), run the ordinary algorithm: if `F` is not callable, throw a `TypeError`; if `F` is a bound function, redo the check against its bound target function; read `F.prototype`; if that is not an object, throw a `TypeError`; then walk `x`'s prototype chain comparing each link with `===` against `F.prototype`; return `false` at the end of the chain. Before any of that, if `x` is not an object the ordinary algorithm returns `false`. So `'abc' instanceof String` is `false`, and `42 instanceof Number` is `false`, without an error. A primitive string is not a `String` object, and no autoboxing happens for this operator. ## What throws and what does not The error cases are worth memorising because they surprise people: ```js 'abc' instanceof String; // false — primitives are simply not instances ({}) instanceof 42; // TypeError: right-hand side is not an object ({}) instanceof {}; // TypeError: right-hand side is not callable function F() {} F.prototype = 5; // legal for an ordinary function ({}) instanceof F; // TypeError: F.prototype is not an object ``` A `TypeError` from `instanceof` therefore always points at the right-hand side, never at the left. ## Live reads of F.prototype Because the operator reads `F.prototype` when it runs, the relationship between an object and a function is not frozen at construction: ```js function A() {} const a = new A(); a instanceof A; // true A.prototype = {}; // brand-new object a instanceof A; // false — a still links to the OLD prototype object const b = new A(); b instanceof A; // true — b links to the new one a instanceof A; // still false ``` That pair of objects, both produced by calling `new A()`, now disagree about whether they are instances of `A`. This is the crispest demonstration that the operator is about the current chain, not about provenance. The same mechanism runs the other way: since `Object.setPrototypeOf` can splice any object into any chain, an object never touched by `A` can be made to pass: ```js const fake = Object.create(A.prototype); fake instanceof A; // true — never went through new A() ``` ## Inheritance chains and built-ins Because the search walks the entire chain, `instanceof` is naturally polymorphic: ```js class Animal {} class Dog extends Animal {} const d = new Dog(); d instanceof Dog; // true d instanceof Animal; // true — Animal.prototype is further up the chain d instanceof Object; // true — Object.prototype terminates most chains ``` An object created with `Object.create(null)` has an empty chain, so `obj instanceof Object` is `false` — a useful reminder that "everything is an object" is a simplification. ## Bound functions `f.bind(...)` produces a function with no own `prototype` property. If `instanceof` naively read `Bound.prototype` it would find `undefined` and throw. Instead the algorithm unwraps the binding and checks against the target function's prototype: ```js function A() {} const a = new A(); const BoundA = A.bind(null); BoundA.prototype; // undefined a instanceof BoundA; // true — checked against A.prototype ``` ## Practical reading Use `instanceof` when you control both the objects and the constructor in the same program and the same realm — checking your own error subclasses in a `catch` block is the classic good use. Be aware of its two structural weaknesses: the answer depends on a mutable `F.prototype`, and identity comparison means two structurally identical functions from different sources never recognise each other's objects. Neither is a bug; both fall directly out of "walk the chain and compare by identity".