El método instanceof de JS está escrito a mano.

introducción al método

¿Qué es una instancia de?

Se utiliza para detectar si el atributo de prototipo del constructor aparece en la cadena de prototipos de un objeto de instancia .

Sintaxis: objeto instancia del constructor
objeto: una instancia objeto
constructor: un constructor

En resumen, se usa para detectar si constructor.prototype existe en la cadena de prototipos del objeto de parámetro.

Comprensión personal:

instanceof se usa para juzgar si el objeto de la izquierda es un objeto instanciado del constructor de la derecha , o si el objeto de la izquierda puede buscar en la cadena de prototipos a través de su prototipo implícito **[[proto]]** Ir al objeto prototipo de la función a la derecha, es decir, devuelve verdadero si el objeto prototipo de función aparece en la cadena prototipo del objeto de instancia.

Comprensión popular: si el lado derecho es el padre, el abuelo o el antepasado del lado izquierdo, siempre que el objeto del lado izquierdo herede de la función del lado derecho, es cierto

Cómo usar instancia de:

instancia de objeto del constructor, tiene dos parámetros obligatorios, el lado izquierdo debe ser un tipo de objeto y el lado derecho debe ser un tipo de función. El valor devuelto es de tipo booleano

Nota: puede pensar que todo en js es un objeto. Esta comprensión incorrecta puede inducir a error a todos a aparecer de esta manera: 'str' instancia de String, el valor de retorno es falso, porque 'str' es una cadena simple y está relacionada a String La cadena creada por el constructor (new String('str')) es diferente, puede imprimirla en la consola para ver, su valor se encapsulará en una cadena de tipo de objeto String, de manera similar, new Number(3) instancia de número, nuevo booleano (verdadero) instancia de booleano ... y así sucesivamente devuelven verdadero.

Ejemplo de código:

// 定义构造函数
function C () {}
function D () {}

// 实例化一个 o 对象
var o = new C()

// true，true --> C.prototype 在 o 的原型链上
console.log(o instanceof C, o.__proto__ === C.prototype, '此时 o 的 __proto__：', 
o.__proto__, '此时 C 的 prototype：', C.prototype)

// false，false --> D.prototype 不在 o 的原型链上
console.log(o instanceof D, o.__proto__ === D.prototype)

// true true --> Object.prototype 在 o 的原型链上
console.log(o instanceof Object, o.__proto__.__proto__ === Object.prototype)

// 这时我们修改构造函数 C 的原型为一个空对象
C.prototype = {}

// 实例化一个 o2 对象
var o2 = new C()

// true --> C.prototype 在 o2 的原型链上
console.log(o2 instanceof C)

// false，C.prototype 指向了一个空对象,这个空对象不在 o 的原型链上.
console.log(o instanceof C, '此时 o 的 __proto__：', o.__proto__, '此时 C 的 prototype：', C.prototype)
console.log('此时 D 的 prototype：', D.prototype);

// 继承
D.prototype = new C()
console.log('此时 D 的 prototype：', D.prototype);
var o3 = new D()

// true, true --> 因为 o3 是 构造函数 D new 出来的实例对象，所以 D.prototype 一定在 o3 的原型链上
console.log(o3 instanceof D, o3.__proto__ === D.prototype)

// true --> 因为 C.prototype 现在在 o3 的原型链上
console.log(o3 instanceof C)

// true,true --> 上面的结果为什么为 true 呢，看如下代码，D.prototype 是 构造函数 C new 出来的实例对象，所以 C.prototype 一定在 D.prototype 的原型链上
console.log(o3.__proto__ === D.prototype, D.prototype.__proto__ === C.prototype);

// true 相当于如下代码
console.log(o3.__proto__.__proto__ === C.prototype);

empezar a escribir a mano

De lo anterior, podemos saber que el principio de instancia de juicio es: a través del atributo prototipo implícito __ proto __ del objeto de la izquierda, busque la cadena de prototipo capa por capa, encuentre el prototipo del atributo del objeto prototipo del constructor correcto y regrese verdadero. Saber esto facilita la escritura de su propia instancia de.

Nota: Debe implementarse con la ayuda de un bucle.

function myInstanceof(obj, func) {
    if(!['function', 'object'].includes(typeof obj) || obj === null) {
    	// 基本数据类型直接返回false，因为不满足instanceof的左侧参数是对象或者说引用类型
        return false
    }
    let objProto = obj.__proto__, funcProto = func.prototype
    while(objProto !== funcProto) {
    	// obj.__proto__不等于func.prototype时，继续通过__proto__向上层查找
    	// 当找到原型链尽头Object.prototype.__proto__=null 时还未找到，就返回false
        objProto = objProto.__proto__
        if(objProto === null){
            return false
        }
    }
    // obj.__proto__ 等于 prototype = func.prototype 时，不会进入上面循环，返回true
    // 不等进入上面循环，找到相等时会跳出循环，走到这里返回true
    return true
}
//测试
function A(){}
let a=new A;
console.log(myInstanceof(a,A))//true
console.log(myInstanceof([],A))//false