Javaｓｃｒｉｐｔ中的instanceof学习课程

语法
对象实例构造函数

参数

对象：

要检测的对象。

Constructor：

一个构造函数

描述：

instanceof运算符用于检测是否对参数对象的原型链中存在的constructor.prototype。

定义构造函数
函数（c）{ }
函数（d）{ }

新的C（）；

/ /真的，因为object.getprototypeof（O）= c.prototype
O是C；

/ /假，因为d.prototype不是O原型链
O是D；

o实例对象； / /真的，因为object.prototype.isprototypeof（O）返回true
c.prototype实例对象 / /真的。

c.prototype = { }；
新的C（）；

O2是C； / /真的

O是C； / /假，C.prototype指向一个空对象，在原型链O空对象

d.prototype =新（C）； / /继承
新的D（）；
O3是D； / /真的
O3是C； / /真的

注意如果obj instanceof Foo或真实的表达，并不意味着表达总是回到现实，因为这foo.prototype属性的值可能会发生变化，在原型链中可能存在的对象的变化值，则表达式的值为假。在另一个案例，原文的价值会发生变化，变化的是obj对象的原型链，虽然在目前的ES规范，我们只能读取对象的原型并不能改变它，但与非标准__proto__魔力的帮助下，可以实现的。例如，__proto__ obj实例对象。= { }，foo返回false。

实例和多个全局对象（多帧或多个窗口之间的相互作用）

在浏览器中，我们的脚本可能需要多个窗口之间的相互作用。多窗口多的全球环境，和全球不同的环境有不同的全局对象，具有不同的内置类型的构造函数。这可能会导致一些问题。例如，instanceof窗口的表达。帧{ 0 }，{ }数组将返回false，因为Array.prototype！= =窗口。帧{ 0 }。Array.prototype，所以你必须使用array.isarray（myobj时）或Object.prototype.toString.call（myobj时）={对象数组} 判断myobj时是一个数组。

样品

常规使用instanceof判断是B型。
console.log（真是布尔）； / /假
console.log（新号码是多少（1））； / /真的

实例也可以判断母型：
函数（父）{ }
函数（子）{ }
child.prototype =新的父亲（）；
var =新的子（）；
console.log（一个是小孩）； / /真的
console.log（一个是父亲）； / /真的

子构造函数从父继承，实例A对子结构毫无疑问，但它为什么是父的实例呢事实上，这是运营商的核心可以用下面的代码简单描述：
函数检查（a，b）{
而（a.__proto__）{
如果（a.__proto__ = b.prototype）
返回true；
a a.__proto__；
}
返回false；
}

函数（富）{ }
console.log（对象实例对象=检查（对象、客体） / /真实）；
console.log（函数是函数=检查（功能、作用） / /真实）；
console.log（数是数=检查（数量、号码） / /真实）；
console.log（字符串是字符串（String，String）=检查）； / /真的
console.log（函数实例对象=检查（函数对象） / /真实）；
console.log（foo instanceof检查功能=（Foo，函数） / /真实）；
console.log（foo instanceof Foo =检查（Foo Foo））； / /真的

简单地说，如果A是B的一个例子，A肯定可以使用B原型中定义的方法和属性。然后，通过代码b.prototype具有对象的原型链相同的值，所以它总是随着A.原型链

另外，值得注意的是字符串、数字、布尔函数和函数都是函数，函数是由函数统一的。因此，像任何简单的函数一样，可以在函数上使用原型属性。
函数。原型= 10；
console.log（字符串，）； / / 10

最后，让我们来讨论前两个问题。
为了便于表达式的表达，首先给出了左右表达式的表达式。
功能：功能、functionR =功能；
按规范逐步演绎
O = = function.prototype functionr.prototype
L = = function.prototype __proto__功能。
第一判决
O = L
返回true

为了便于表达式的表达，首先给出了左右表达式的表达式。
stringr字符串字符串stringl =，=；
按规范逐步演绎
O = = string.prototype stringr.prototype
L = = function.prototype __proto__ stringl。
第一判决
o！= L
/ /周期再次找到我，__proto__
L =字符串。__proto__ = object.prototype原型。
第二次判决
o！= L
再次找到L / / __proto__
L =字符串。原型。__proto__ = null
第三判断
l = null
返回false