Javascript instanceof 究竟是如何工作的？是慢风格吗？

Question

对于“巨大的库”来说，instanceof 的性能如何？

它是否沿着原型链一个接一个向上移动，与此类似？ ：

//..
var _ = john.constructor;
while (true) {
    if (_ === Human) {
        return true;
    }
    _ = _.prototype.constructor
}
return false;
//..

与在每个对象的属性中存储唯一的接口 ID 号相比，instanceof 的性能是否相对较差。

Answer 1

在 V8（Chrome 的 JS 引擎）中，似乎几乎没有性能影响：

> function A(){}
> function B(){}
> function C(){}
> function D(){}
> B.prototype = new A();
> C.prototype = new B();
> D.prototype = new C();
> 
> var objA = new A();
> var objD = new D();
> 
> var start = (+new Date()); for(var i=0; i<10000000; i++){ objA instanceof A } console.log((+new Date()) - start);
138
> var start = (+new Date()); for(var i=0; i<10000000; i++){ objD instanceof A } console.log((+new Date()) - start);
138

Firefox 显示了相同的行为。

这里有点疯狂，但是：

> var classes = [];
> for(var i=0; i<10000; i++){
>   classes[i] = function(){};
>   i && (classes[i].prototype = new (classes[i-1])());
> }
>
> var obj0 = new classes[0],
>  obj9999 = new classes[9999];
>
> var start = (+new Date()); for(var i=0; i<10000000; i++){ obj0   instanceof classes[0] } console.log((+new Date()) - start);
138
> var start = (+new Date()); for(var i=0; i<10000000; i++){ obj999 instanceof classes[0] } console.log((+new Date()) - start);
138

我认为如果它可以钻取 10,000 个类并且看不到 1 毫秒的性能差异，那么可以安全地假设不会影响性能:)

Answer 2

是的，类似的事情。以下是规范中的相关部分：

11.8.6 instanceof 运算符

产生式RelationalExpression：RelationalExpression instanceof ShiftExpression评估如下：

1. 令lref为计算RelationalExpression的结果。
2. 令lval为GetValue(lref)。
3. 令rref为ShiftExpression的计算结果。
4. 令rval为GetValue(rref)。
5. 如果 Type(rval) 不是 Object，则抛出 TypeError 异常。
6. 如果rval没有[[HasInstance]]内部方法，则抛出TypeError异常。
7. 返回使用参数lval调用rval的[[HasInstance]]内部方法的结果。

其中调用 [[HasInstance]] 方法定义为

15.3.5.3 [[HasInstance]] (V)< /p>

假设F是一个Function对象。

当使用值V调用F的[[HasInstance]]内部方法时，将执行以下步骤：

1. 如果V不是对象，则返回false。
2. 令O为调用属性名为“prototype”的F的[[Get]]内部方法的结果。李>
3. 如果 Type(O) 不是 Object，则抛出 TypeError 异常。
4. 重复
   一个。令V为V的[[Prototype]]内部属性的值。
   b.如果V为null，则返回false。
   c.如果O和V引用同一个对象，则返回true。

关于性能：这可能取决于浏览器中的实际实现。它们之间可能存在巨大差异，因此最好的办法是制定一些基准测试，例如使用 http://jsperf.com/。

---

instanceof 的一个问题是，如果您在来自不同上下文（例如框架或 iframe）的元素上调用它，它可能无法工作。例如，让a是一个可以通过iframe.contentWindow.a访问的对象，并且你想测试它是否是一个数组，那么

iframe.contentWindow.a instanceof Array

将返回false< /代码>。

Answer 3

根据 Felix Kling 的引用，instanceof 所做的一切（不包括错误检查）都是检查 Function 的原型属性（必须是一个对象）是否可以在原型链的某个位置找到，

person instanceof Object
// ROUGHTLY does
return (
     person.__proto__==Object.prototype
  || person.__proto__.__proto__==Object.prototype
  || ... );

下面是一些伪代码：

person instanceof Person
//ROUGHTLY equals
person.instanceOf(Person)

person.instanceOf = function(Person) {
    if(typeof Person!='object') throw new TypeError;
    if(!([[HasInstance]] in Person)) throw new TypeError;
    return Person.[[HasInstance]](this /* person */)
}


Person.[[HasInstance]] = function(V) {
    if(typeof V!='object') return false;
    var O = this.prototype;
    if(typeof O!='object') throw new TypeError;
    while(true) {
        V = V.__proto__; // [[prototype]] (hidden) property
        if(V==null) return false;
        if(V==O) return true;
    }
}