The
// defining constructors
function C[] {}
function D[] {}
const o = new C[];
// true, because: Object.getPrototypeOf[o] === C.prototype
o instanceof C;
// false, because D.prototype is nowhere in o's prototype chain
o 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 anymore
o instanceof C;
D.prototype = new C[]; // add C to [[Prototype]] linkage of D
const o3 = new D[];
o3 instanceof D; // true
o3 instanceof C; // true since C.prototype is now in o3's prototype chain
5 operator tests to see if the // defining constructors
function C[] {}
function D[] {}
const o = new C[];
// true, because: Object.getPrototypeOf[o] === C.prototype
o instanceof C;
// false, because D.prototype is nowhere in o's prototype chain
o 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 anymore
o instanceof C;
D.prototype = new C[]; // add C to [[Prototype]] linkage of D
const o3 = new D[];
o3 instanceof D; // true
o3 instanceof C; // true since C.prototype is now in o3's prototype chain
6 property of a constructor appears anywhere in the prototype chain of an object. The return value is a boolean value. Its behavior can be customized with // defining constructors
function C[] {}
function D[] {}
const o = new C[];
// true, because: Object.getPrototypeOf[o] === C.prototype
o instanceof C;
// false, because D.prototype is nowhere in o's prototype chain
o 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 anymore
o instanceof C;
D.prototype = new C[]; // add C to [[Prototype]] linkage of D
const o3 = new D[];
o3 instanceof D; // true
o3 instanceof C; // true since C.prototype is now in o3's prototype chain
7.object instanceof constructor
// defining constructors
function C[] {}
function D[] {}
const o = new C[];
// true, because: Object.getPrototypeOf[o] === C.prototype
o instanceof C;
// false, because D.prototype is nowhere in o's prototype chain
o 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 anymore
o instanceof C;
D.prototype = new C[]; // add C to [[Prototype]] linkage of D
const o3 = new D[];
o3 instanceof D; // true
o3 instanceof C; // true since C.prototype is now in o3's prototype chain
8The object to test.
// defining constructors
function C[] {}
function D[] {}
const o = new C[];
// true, because: Object.getPrototypeOf[o] === C.prototype
o instanceof C;
// false, because D.prototype is nowhere in o's prototype chain
o 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 anymore
o instanceof C;
D.prototype = new C[]; // add C to [[Prototype]] linkage of D
const o3 = new D[];
o3 instanceof D; // true
o3 instanceof C; // true since C.prototype is now in o3's prototype chain
9Constructor to test against.
class A {}
class B extends A {}
const o1 = new A[];
// true, because Object.getPrototypeOf[o1] === A.prototype
o1 instanceof A;
// false, because B.prototype is nowhere in o1's prototype chain
o1 instanceof B;
const o2 = new B[];
// true, because Object.getPrototypeOf[Object.getPrototypeOf[o2]] === A.prototype
o2 instanceof A;
// true, because Object.getPrototypeOf[o2] === B.prototype
o2 instanceof B;
0Thrown if
// defining constructors
function C[] {}
function D[] {}
const o = new C[];
// true, because: Object.getPrototypeOf[o] === C.prototype
o instanceof C;
// false, because D.prototype is nowhere in o's prototype chain
o 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 anymore
o instanceof C;
D.prototype = new C[]; // add C to [[Prototype]] linkage of D
const o3 = new D[];
o3 instanceof D; // true
o3 instanceof C; // true since C.prototype is now in o3's prototype chain
9 is not an object. If // defining constructors
function C[] {}
function D[] {}
const o = new C[];
// true, because: Object.getPrototypeOf[o] === C.prototype
o instanceof C;
// false, because D.prototype is nowhere in o's prototype chain
o 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 anymore
o instanceof C;
D.prototype = new C[]; // add C to [[Prototype]] linkage of D
const o3 = new D[];
o3 instanceof D; // true
o3 instanceof C; // true since C.prototype is now in o3's prototype chain
9 doesn't have a class A {}
class B extends A {}
const o1 = new A[];
// true, because Object.getPrototypeOf[o1] === A.prototype
o1 instanceof A;
// false, because B.prototype is nowhere in o1's prototype chain
o1 instanceof B;
const o2 = new B[];
// true, because Object.getPrototypeOf[Object.getPrototypeOf[o2]] === A.prototype
o2 instanceof A;
// true, because Object.getPrototypeOf[o2] === B.prototype
o2 instanceof B;
3 method, it must also be a function.The
// defining constructors
function C[] {}
function D[] {}
const o = new C[];
// true, because: Object.getPrototypeOf[o] === C.prototype
o instanceof C;
// false, because D.prototype is nowhere in o's prototype chain
o 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 anymore
o instanceof C;
D.prototype = new C[]; // add C to [[Prototype]] linkage of D
const o3 = new D[];
o3 instanceof D; // true
o3 instanceof C; // true since C.prototype is now in o3's prototype chain
5 operator tests the presence of class A {}
class B extends A {}
const o1 = new A[];
// true, because Object.getPrototypeOf[o1] === A.prototype
o1 instanceof A;
// false, because B.prototype is nowhere in o1's prototype chain
o1 instanceof B;
const o2 = new B[];
// true, because Object.getPrototypeOf[Object.getPrototypeOf[o2]] === A.prototype
o2 instanceof A;
// true, because Object.getPrototypeOf[o2] === B.prototype
o2 instanceof B;
5 in // defining constructors
function C[] {}
function D[] {}
const o = new C[];
// true, because: Object.getPrototypeOf[o] === C.prototype
o instanceof C;
// false, because D.prototype is nowhere in o's prototype chain
o 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 anymore
o instanceof C;
D.prototype = new C[]; // add C to [[Prototype]] linkage of D
const o3 = new D[];
o3 instanceof D; // true
o3 instanceof C; // true since C.prototype is now in o3's prototype chain
8's prototype chain. This usually [though ] means // defining constructors
function C[] {}
function D[] {}
const o = new C[];
// true, because: Object.getPrototypeOf[o] === C.prototype
o instanceof C;
// false, because D.prototype is nowhere in o's prototype chain
o 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 anymore
o instanceof C;
D.prototype = new C[]; // add C to [[Prototype]] linkage of D
const o3 = new D[];
o3 instanceof D; // true
o3 instanceof C; // true since C.prototype is now in o3's prototype chain
8 was constructed with // defining constructors
function C[] {}
function D[] {}
const o = new C[];
// true, because: Object.getPrototypeOf[o] === C.prototype
o instanceof C;
// false, because D.prototype is nowhere in o's prototype chain
o 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 anymore
o instanceof C;
D.prototype = new C[]; // add C to [[Prototype]] linkage of D
const o3 = new D[];
o3 instanceof D; // true
o3 instanceof C; // true since C.prototype is now in o3's prototype chain
9.// defining constructors
function C[] {}
function D[] {}
const o = new C[];
// true, because: Object.getPrototypeOf[o] === C.prototype
o instanceof C;
// false, because D.prototype is nowhere in o's prototype chain
o 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 anymore
o instanceof C;
D.prototype = new C[]; // add C to [[Prototype]] linkage of D
const o3 = new D[];
o3 instanceof D; // true
o3 instanceof C; // true since C.prototype is now in o3's prototype chain
Note that the value of an
// defining constructors
function C[] {}
function D[] {}
const o = new C[];
// true, because: Object.getPrototypeOf[o] === C.prototype
o instanceof C;
// false, because D.prototype is nowhere in o's prototype chain
o 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 anymore
o instanceof C;
D.prototype = new C[]; // add C to [[Prototype]] linkage of D
const o3 = new D[];
o3 instanceof D; // true
o3 instanceof C; // true since C.prototype is now in o3's prototype chain
5 test can change if class A {}
class B extends A {}
const o1 = new A[];
// true, because Object.getPrototypeOf[o1] === A.prototype
o1 instanceof A;
// false, because B.prototype is nowhere in o1's prototype chain
o1 instanceof B;
const o2 = new B[];
// true, because Object.getPrototypeOf[Object.getPrototypeOf[o2]] === A.prototype
o2 instanceof A;
// true, because Object.getPrototypeOf[o2] === B.prototype
o2 instanceof B;
5 is re-assigned after creating the object [which is usually discouraged]. It can also be changed by changing // defining constructors
function C[] {}
function D[] {}
const o = new C[];
// true, because: Object.getPrototypeOf[o] === C.prototype
o instanceof C;
// false, because D.prototype is nowhere in o's prototype chain
o 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 anymore
o instanceof C;
D.prototype = new C[]; // add C to [[Prototype]] linkage of D
const o3 = new D[];
o3 instanceof D; // true
o3 instanceof C; // true since C.prototype is now in o3's prototype chain
8's prototype using class Base {}
const BoundBase = Base.bind[null, 1, 2];
console.log[new Base[] instanceof BoundBase]; // true
2.Classes behave in the same way, because classes also have the
// defining constructors
function C[] {}
function D[] {}
const o = new C[];
// true, because: Object.getPrototypeOf[o] === C.prototype
o instanceof C;
// false, because D.prototype is nowhere in o's prototype chain
o 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 anymore
o instanceof C;
D.prototype = new C[]; // add C to [[Prototype]] linkage of D
const o3 = new D[];
o3 instanceof D; // true
o3 instanceof C; // true since C.prototype is now in o3's prototype chain
6 property.class A {}
class B extends A {}
const o1 = new A[];
// true, because Object.getPrototypeOf[o1] === A.prototype
o1 instanceof A;
// false, because B.prototype is nowhere in o1's prototype chain
o1 instanceof B;
const o2 = new B[];
// true, because Object.getPrototypeOf[Object.getPrototypeOf[o2]] === A.prototype
o2 instanceof A;
// true, because Object.getPrototypeOf[o2] === B.prototype
o2 instanceof B;
For bound functions,
// defining constructors
function C[] {}
function D[] {}
const o = new C[];
// true, because: Object.getPrototypeOf[o] === C.prototype
o instanceof C;
// false, because D.prototype is nowhere in o's prototype chain
o 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 anymore
o instanceof C;
D.prototype = new C[]; // add C to [[Prototype]] linkage of D
const o3 = new D[];
o3 instanceof D; // true
o3 instanceof C; // true since C.prototype is now in o3's prototype chain
5 looks up for the // defining constructors
function C[] {}
function D[] {}
const o = new C[];
// true, because: Object.getPrototypeOf[o] === C.prototype
o instanceof C;
// false, because D.prototype is nowhere in o's prototype chain
o 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 anymore
o instanceof C;
D.prototype = new C[]; // add C to [[Prototype]] linkage of D
const o3 = new D[];
o3 instanceof D; // true
o3 instanceof C; // true since C.prototype is now in o3's prototype chain
6 property on the target function, since bound functions don't have // defining constructors
function C[] {}
function D[] {}
const o = new C[];
// true, because: Object.getPrototypeOf[o] === C.prototype
o instanceof C;
// false, because D.prototype is nowhere in o's prototype chain
o 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 anymore
o instanceof C;
D.prototype = new C[]; // add C to [[Prototype]] linkage of D
const o3 = new D[];
o3 instanceof D; // true
o3 instanceof C; // true since C.prototype is now in o3's prototype chain
6.class Base {}
const BoundBase = Base.bind[null, 1, 2];
console.log[new Base[] instanceof BoundBase]; // true
If
// defining constructors
function C[] {}
function D[] {}
const o = new C[];
// true, because: Object.getPrototypeOf[o] === C.prototype
o instanceof C;
// false, because D.prototype is nowhere in o's prototype chain
o 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 anymore
o instanceof C;
D.prototype = new C[]; // add C to [[Prototype]] linkage of D
const o3 = new D[];
o3 instanceof D; // true
o3 instanceof C; // true since C.prototype is now in o3's prototype chain
9 has a // defining constructors
function C[] {}
function D[] {}
const o = new C[];
// true, because: Object.getPrototypeOf[o] === C.prototype
o instanceof C;
// false, because D.prototype is nowhere in o's prototype chain
o 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 anymore
o instanceof C;
D.prototype = new C[]; // add C to [[Prototype]] linkage of D
const o3 = new D[];
o3 instanceof D; // true
o3 instanceof C; // true since C.prototype is now in o3's prototype chain
7 method, the method will be called in priority, with // defining constructors
function C[] {}
function D[] {}
const o = new C[];
// true, because: Object.getPrototypeOf[o] === C.prototype
o instanceof C;
// false, because D.prototype is nowhere in o's prototype chain
o 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 anymore
o instanceof C;
D.prototype = new C[]; // add C to [[Prototype]] linkage of D
const o3 = new D[];
o3 instanceof D; // true
o3 instanceof C; // true since C.prototype is now in o3's prototype chain
8 as its only argument and // defining constructors
function C[] {}
function D[] {}
const o = new C[];
// true, because: Object.getPrototypeOf[o] === C.prototype
o instanceof C;
// false, because D.prototype is nowhere in o's prototype chain
o 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 anymore
o instanceof C;
D.prototype = new C[]; // add C to [[Prototype]] linkage of D
const o3 = new D[];
o3 instanceof D; // true
o3 instanceof C; // true since C.prototype is now in o3's prototype chain
9 as // 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
1.// 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
JavaScript execution environments [windows, frames, etc.] are each in their own realm. This means that they have different built-ins [different global object, different constructors, etc.]. This may result in unexpected results. For instance,
// 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
2 will return // 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
3, because // 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
4 and arrays in the current realm inherit from the former.This may not make sense at first, but for scripts dealing with multiple frames or windows, and passing objects from one context to another via functions, this will be a valid and strong issue. For instance, you can securely check if a given object is in fact an Array using
// 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
5, neglecting which realm it comes from.For example, to check if a
// 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
6 is an // 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
7 in a different context, you can use // 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
8.The following example shows the behavior of
// defining constructors
function C[] {}
function D[] {}
const o = new C[];
// true, because: Object.getPrototypeOf[o] === C.prototype
o instanceof C;
// false, because D.prototype is nowhere in o's prototype chain
o 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 anymore
o instanceof C;
D.prototype = new C[]; // add C to [[Prototype]] linkage of D
const o3 = new D[];
o3 instanceof D; // true
o3 instanceof C; // true since C.prototype is now in o3's prototype chain
5 with const literalString = "This is a literal string";
const stringObject = new String["String created with constructor"];
literalString instanceof String; // false, string primitive is not a String
stringObject instanceof String; // true
literalString instanceof Object; // false, string primitive is not an Object
stringObject instanceof Object; // true
stringObject instanceof Date; // false
0 objects.const literalString = "This is a literal string";
const stringObject = new String["String created with constructor"];
literalString instanceof String; // false, string primitive is not a String
stringObject instanceof String; // true
literalString instanceof Object; // false, string primitive is not an Object
stringObject instanceof Object; // true
stringObject instanceof Date; // false
The following example shows the behavior of
// defining constructors
function C[] {}
function D[] {}
const o = new C[];
// true, because: Object.getPrototypeOf[o] === C.prototype
o instanceof C;
// false, because D.prototype is nowhere in o's prototype chain
o 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 anymore
o instanceof C;
D.prototype = new C[]; // add C to [[Prototype]] linkage of D
const o3 = new D[];
o3 instanceof D; // true
o3 instanceof C; // true since C.prototype is now in o3's prototype chain
5 with const literalString = "This is a literal string";
const stringObject = new String["String created with constructor"];
literalString instanceof String; // false, string primitive is not a String
stringObject instanceof String; // true
literalString instanceof Object; // false, string primitive is not an Object
stringObject instanceof Object; // true
stringObject instanceof Date; // false
2 objects.const myDate = new Date[];
myDate instanceof Date; // true
myDate instanceof Object; // true
myDate instanceof String; // false
The following example shows the behavior of
// defining constructors
function C[] {}
function D[] {}
const o = new C[];
// true, because: Object.getPrototypeOf[o] === C.prototype
o instanceof C;
// false, because D.prototype is nowhere in o's prototype chain
o 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 anymore
o instanceof C;
D.prototype = new C[]; // add C to [[Prototype]] linkage of D
const o3 = new D[];
o3 instanceof D; // true
o3 instanceof C; // true since C.prototype is now in o3's prototype chain
5 with objects created using const literalString = "This is a literal string";
const stringObject = new String["String created with constructor"];
literalString instanceof String; // false, string primitive is not a String
stringObject instanceof String; // true
literalString instanceof Object; // false, string primitive is not an Object
stringObject instanceof Object; // true
stringObject instanceof Date; // false
4.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; // true
rect instanceof Shape; // true
rect instanceof Rectangle; // true
rect instanceof String; // false
const 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 above
nullObject instanceof Object; // false, prototype is end of prototype chain [null]
The following code creates an object type
const literalString = "This is a literal string";
const stringObject = new String["String created with constructor"];
literalString instanceof String; // false, string primitive is not a String
stringObject instanceof String; // true
literalString instanceof Object; // false, string primitive is not an Object
stringObject instanceof Object; // true
stringObject instanceof Date; // false
5 and an instance of that object type, const literalString = "This is a literal string";
const stringObject = new String["String created with constructor"];
literalString instanceof String; // false, string primitive is not a String
stringObject instanceof String; // true
literalString instanceof Object; // false, string primitive is not an Object
stringObject instanceof Object; // true
stringObject instanceof Date; // false
6. The // defining constructors
function C[] {}
function D[] {}
const o = new C[];
// true, because: Object.getPrototypeOf[o] === C.prototype
o instanceof C;
// false, because D.prototype is nowhere in o's prototype chain
o 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 anymore
o instanceof C;
D.prototype = new C[]; // add C to [[Prototype]] linkage of D
const o3 = new D[];
o3 instanceof D; // true
o3 instanceof C; // true since C.prototype is now in o3's prototype chain
5 operator demonstrates that the const literalString = "This is a literal string";
const stringObject = new String["String created with constructor"];
literalString instanceof String; // false, string primitive is not a String
stringObject instanceof String; // true
literalString instanceof Object; // false, string primitive is not an Object
stringObject instanceof Object; // true
stringObject instanceof Date; // false
6 object is of type const literalString = "This is a literal string";
const stringObject = new String["String created with constructor"];
literalString instanceof String; // false, string primitive is not a String
stringObject instanceof String; // true
literalString instanceof Object; // false, string primitive is not an Object
stringObject instanceof Object; // true
stringObject instanceof Date; // false
5 and of type const myDate = new Date[];
myDate instanceof Date; // true
myDate instanceof Object; // true
myDate instanceof String; // false
0.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 true
const b = mycar instanceof Object; // returns true
To test if an object is not an
// defining constructors
function C[] {}
function D[] {}
const o = new C[];
// true, because: Object.getPrototypeOf[o] === C.prototype
o instanceof C;
// false, because D.prototype is nowhere in o's prototype chain
o 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 anymore
o instanceof C;
D.prototype = new C[]; // add C to [[Prototype]] linkage of D
const o3 = new D[];
o3 instanceof D; // true
o3 instanceof C; // true since C.prototype is now in o3's prototype chain
5 a specific constructor, you can do:if [![mycar instanceof Car]] {
// Do something, like:
// mycar = new Car[mycar]
}
This is really different from:
// defining constructors
function C[] {}
function D[] {}
const o = new C[];
// true, because: Object.getPrototypeOf[o] === C.prototype
o instanceof C;
// false, because D.prototype is nowhere in o's prototype chain
o 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 anymore
o instanceof C;
D.prototype = new C[]; // add C to [[Prototype]] linkage of D
const o3 = new D[];
o3 instanceof D; // true
o3 instanceof C; // true since C.prototype is now in o3's prototype chain
0This will always be
// 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
3. [const myDate = new Date[];
myDate instanceof Date; // true
myDate instanceof Object; // true
myDate instanceof String; // false
3 will be evaluated before // defining constructors
function C[] {}
function D[] {}
const o = new C[];
// true, because: Object.getPrototypeOf[o] === C.prototype
o instanceof C;
// false, because D.prototype is nowhere in o's prototype chain
o 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 anymore
o instanceof C;
D.prototype = new C[]; // add C to [[Prototype]] linkage of D
const o3 = new D[];
o3 instanceof D; // true
o3 instanceof C; // true since C.prototype is now in o3's prototype chain
5, so you always try to know if a boolean is an instance of const literalString = "This is a literal string";
const stringObject = new String["String created with constructor"];
literalString instanceof String; // false, string primitive is not a String
stringObject instanceof String; // true
literalString instanceof Object; // false, string primitive is not an Object
stringObject instanceof Object; // true
stringObject instanceof Date; // false
5].A common pitfall of using
// defining constructors
function C[] {}
function D[] {}
const o = new C[];
// true, because: Object.getPrototypeOf[o] === C.prototype
o instanceof C;
// false, because D.prototype is nowhere in o's prototype chain
o 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 anymore
o instanceof C;
D.prototype = new C[]; // add C to [[Prototype]] linkage of D
const o3 = new D[];
o3 instanceof D; // true
o3 instanceof C; // true since C.prototype is now in o3's prototype chain
5 is believing that, if const myDate = new Date[];
myDate instanceof Date; // true
myDate instanceof Object; // true
myDate instanceof String; // false
7, then const myDate = new Date[];
myDate instanceof Date; // true
myDate instanceof Object; // true
myDate instanceof String; // false
8 was created using const myDate = new Date[];
myDate instanceof Date; // true
myDate instanceof Object; // true
myDate instanceof String; // false
9 as constructor. This is not true, because const myDate = new Date[];
myDate instanceof Date; // true
myDate instanceof Object; // true
myDate instanceof String; // false
8 could be directly assigned with 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; // true
rect instanceof Shape; // true
rect instanceof Rectangle; // true
rect instanceof String; // false
const 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 above
nullObject instanceof Object; // false, prototype is end of prototype chain [null]
1 as its prototype. In this case, if your code reads private fields of const myDate = new Date[];
myDate instanceof Date; // true
myDate instanceof Object; // true
myDate instanceof String; // false
9 from const myDate = new Date[];
myDate instanceof Date; // true
myDate instanceof Object; // true
myDate instanceof String; // false
8, it would still fail:// defining constructors
function C[] {}
function D[] {}
const o = new C[];
// true, because: Object.getPrototypeOf[o] === C.prototype
o instanceof C;
// false, because D.prototype is nowhere in o's prototype chain
o 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 anymore
o instanceof C;
D.prototype = new C[]; // add C to [[Prototype]] linkage of D
const o3 = new D[];
o3 instanceof D; // true
o3 instanceof C; // true since C.prototype is now in o3's prototype chain
1To avoid this, you can override the behavior of
// defining constructors
function C[] {}
function D[] {}
const o = new C[];
// true, because: Object.getPrototypeOf[o] === C.prototype
o instanceof C;
// false, because D.prototype is nowhere in o's prototype chain
o 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 anymore
o instanceof C;
D.prototype = new C[]; // add C to [[Prototype]] linkage of D
const o3 = new D[];
o3 instanceof D; // true
o3 instanceof C; // true since C.prototype is now in o3's prototype chain
5 by adding a // defining constructors
function C[] {}
function D[] {}
const o = new C[];
// true, because: Object.getPrototypeOf[o] === C.prototype
o instanceof C;
// false, because D.prototype is nowhere in o's prototype chain
o 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 anymore
o instanceof C;
D.prototype = new C[]; // add C to [[Prototype]] linkage of D
const o3 = new D[];
o3 instanceof D; // true
o3 instanceof C; // true since C.prototype is now in o3's prototype chain
7 method to const myDate = new Date[];
myDate instanceof Date; // true
myDate instanceof Object; // true
myDate instanceof String; // false
9, so that it does a branded check with 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; // true
rect instanceof Shape; // true
rect instanceof Rectangle; // true
rect instanceof String; // false
const 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 above
nullObject instanceof Object; // false, prototype is end of prototype chain [null]
7:// defining constructors
function C[] {}
function D[] {}
const o = new C[];
// true, because: Object.getPrototypeOf[o] === C.prototype
o instanceof C;
// false, because D.prototype is nowhere in o's prototype chain
o 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 anymore
o instanceof C;
D.prototype = new C[]; // add C to [[Prototype]] linkage of D
const o3 = new D[];
o3 instanceof D; // true
o3 instanceof C; // true since C.prototype is now in o3's prototype chain
2Note that you may want to limit this behavior to the current class; otherwise, it could lead to false positives for subclasses: