function Car(make, model, year) {  this.make = make;  this.model = model;  this.year = year;}const auto = new Car("Honda", "Accord", 1998);console.log(auto instanceof Car);// Expected output: trueconsole.log(auto instanceof Object);// Expected output: true

object instanceof constructor

// defining constructorsfunction C() {}function D() {}const o = new C();// true, because: Object.getPrototypeOf(o) === C.prototypeo instanceof C;// false, because D.prototype is nowhere in o's prototype chaino instanceof D;o instanceof Object; // true, because:C.prototype instanceof Object; // true// Re-assign `constructor.prototype`: you should// rarely do this in practice.C.prototype = {};const o2 = new C();o2 instanceof C; // true// false, because C.prototype is nowhere in// o's prototype chain anymoreo instanceof C;D.prototype = new C(); // add C to [[Prototype]] linkage of Dconst o3 = new D();o3 instanceof D; // trueo3 instanceof C; // true since C.prototype is now in o3's prototype chain

class A {}class B extends A {}const o1 = new A();// true, because Object.getPrototypeOf(o1) === A.prototypeo1 instanceof A;// false, because B.prototype is nowhere in o1's prototype chaino1 instanceof B;const o2 = new B();// true, because Object.getPrototypeOf(Object.getPrototypeOf(o2)) === A.prototypeo2 instanceof A;// true, because Object.getPrototypeOf(o2) === B.prototypeo2 instanceof B;

class Base {}const BoundBase = Base.bind(null, 1, 2);console.log(new Base() instanceof BoundBase); // true

// This class allows plain objects to be disguised as this class's instance,// as long as the object has a particular flag as its property.class Forgeable {  static isInstanceFlag = Symbol("isInstanceFlag");  static [Symbol.hasInstance](obj) {    return Forgeable.isInstanceFlag in obj;  }}const obj = { [Forgeable.isInstanceFlag]: true };console.log(obj instanceof Forgeable); // true

const literalString = "This is a literal string";const stringObject = new String("String created with constructor");literalString instanceof String; // false, string primitive is not a StringstringObject instanceof String; // trueliteralString instanceof Object; // false, string primitive is not an ObjectstringObject instanceof Object; // truestringObject instanceof Date; // false

const myMap = new Map();myMap instanceof Map; // truemyMap instanceof Object; // truemyMap instanceof String; // false

function Shape() {}function Rectangle() {  Shape.call(this); // call super constructor.}Rectangle.prototype = Object.create(Shape.prototype);Rectangle.prototype.constructor = Rectangle;const rect = new Rectangle();rect instanceof Object; // truerect instanceof Shape; // truerect instanceof Rectangle; // truerect instanceof String; // falseconst literalObject = {};const nullObject = Object.create(null);nullObject.name = "My object";literalObject instanceof Object; // true, every object literal has Object.prototype as prototype({}) instanceof Object; // true, same case as abovenullObject instanceof Object; // false, prototype is end of prototype chain (null)

function Car(make, model, year) {  this.make = make;  this.model = model;  this.year = year;}const myCar = new Car("Honda", "Accord", 1998);const a = myCar instanceof Car; // returns trueconst b = myCar instanceof Object; // returns true

if (!(myCar instanceof Car)) {  // Do something, like:  // myCar = new Car(myCar)}

if (!myCar instanceof Car) {  // unreachable code}

class C {  #value = "foo";  static getValue(x) {    return x.#value;  }}const x = { __proto__: C.prototype };if (x instanceof C) {  console.log(C.getValue(x)); // TypeError: Cannot read private member #value from an object whose class did not declare it}

class C {  #value = "foo";  static [Symbol.hasInstance](x) {    return #value in x;  }  static getValue(x) {    return x.#value;  }}const x = { __proto__: C.prototype };if (x instanceof C) {  // Doesn't run, because x is not a C  console.log(C.getValue(x));}

class D extends C {}console.log(new C() instanceof D); // true; because D inherits [Symbol.hasInstance] from C

class C {  #value = "foo";  static [Symbol.hasInstance](x) {    return this === C && #value in x;  }}class D extends C {}console.log(new C() instanceof D); // falseconsole.log(new C() instanceof C); // trueconsole.log({ __proto__: C.prototype } instanceof C); // false

Help improve MDN