We know that the instanceof operator is used to check whether an object is an instance of a constructor. The various scenarios in which it returns true are listed below.
1. The object obj is created through new Constructor, then obj instanceof Constructor is true
Copy the code code as follows:
function Person(n, a) {
this.name = n;
this.age = a;
}
var p = new Person('John Backus', 82);
console.log(p instanceof Person); // true
2. If there is an inheritance relationship, the instanceof of the subclass and the parent class will also return true.
Copy the code code as follows:
function A(){}
function B(){}
B.prototype = new A(); // B inherits from A
var b = new B();
console.log(b instanceof A); // true
3. Since Object is the root class, all other custom classes inherit from it, so the instanceof Object of any constructor returns true.
Copy the code code as follows:
function A() {}
var a = new A();
console.log(a instanceof Object); // true
var str = new String('hello');
console.log(str instanceof Object); // true
var num = new Number(1);
console.log(num instanceof Object); // true
Even the constructor itself
Copy the code code as follows:
function A() {}
console.log(A instanceof Object); // true
console.log(String instanceof Object); // true
console.log(Number instanceof Object); // true
4. All constructors instanceof Function return true
Copy the code code as follows:
function A() {}
console.log(A instanceof Function); // true
console.log(String instanceof Function); // true
console.log(Number instanceof Function); // true
The above four points are summarized in one sentence: If an instance is created by a certain class or its subclass, then instanceof returns true. Or if the prototype of a certain constructor exists on the internal prototype chain of object obj, then true is returned. That is, the result of instanceof has no direct relationship with the constructor itself. This is common in many languages.
A class Person is defined in Java, and instance p returns true for both Person and Object.
Copy the code code as follows:
class Person {
public String name;
public int age;
Person (String n, int a) {
this.name = name;
this.age = a;
}
public static void main(String[] args) {
Person p = new Person("John Backus", 82);
System.out.println(p instanceof Person); // true
System.out.println(p instanceof Object); // true
}
}
If there is an inheritance relationship in Java, then the instanceof parent class of the subclass also returns true.
Copy the code code as follows:
// parent class
class Person {
public String name;
public int age;
Person (String n, int a) {
name = name;
age = a;
}
}
// subclass
public class Man extends Person{
public String university;
Man(String n, int a, String s) {
super(n, a);
university = s;
}
public static void main(String[] args) {
Man mm = new Man("John Resig", 29, "PKU");
System.out.println(mm instanceof Man); // true
System.out.println(mm instanceof Person); // also true
}
}
Knowing this, the following performance in JS is not surprising
Copy the code code as follows:
//Define two constructors
function A(){}
function B(){}
A.prototype = B.prototype = {a: 1};
//Create two instances of different constructors respectively
var a = new A();
var b = new B();
console.log(a instanceof B); // true
console.log(b instanceof A); // true
We see that a and b are created with A and B respectively, but both a instanceof B and b instanceof A are true. That is, although a is not created with constructor B, it still returns true. Because B.prototype exists on the internal prototype chain of a.
Due to the dynamic language characteristics of JS, the prototype can be modified at runtime, so it is not surprising that the following returns false. Because A.prototype is no longer in a's internal prototype chain, the chain is interrupted.
Copy the code code as follows:
function A(){}
var a = new A();
A.prototype = {}; // Dynamically modify the prototype, please note that it must be done after creating a
console.log(a instanceof A); // false
Note that writing this also breaks the first point summarized above: the object obj is created through new Constructor, then obj instanceof Constructor is true
Actually in the ECMAScript standard (subject to 5.1), the internal implementation of instanceof will call the internal method [[HasInstance]] of the constructor, which is described as follows
If F is a function object, when F(V) is executed, the following steps will occur:
1. If the left operand V of instanceof is not an object type, return false directly.
Copy the code code as follows:
var a, b = 1, c = true, d = 'hello';
console.log(a instanceof Object); // false here a value is undefined
console.log(b instanceof Object); // false
console.log(c instanceof Object); // false
console.log(d instanceof Object); // false
2/3. Get the prototype attribute of constructor F. If it is not an object type, a TypeError exception must be thrown.
Copy the code code as follows:
function A(){}
A.prototype = 1; // Set the prototype of A to a non-object type
var a = new A();
console.log(a instanceof A);
The exception prompts thrown by each browser are different.
Firefox18:
Chrome24:
Safari6:
Opera12:
IE10:
4. Continuously execute the following logic: set V to the V of the internal prototype, return false if V is null, and return true if both V and O point to the same object.