从instanceof操作符看懂JavaScript原型链

instanceof 操作符简介

对于检测基本数据类型，我们会想到用typeof操作符检测；对于引用类型，我们会想到用instanceof操作符来检测。通常我们使用它来检测某个值是否是某个类型的实例。

let person = new Person('eason')
person instanceof Person // true

instanceof 语言规范及定义

在 Standard ECMA-262 6th Edition 中 instanceof 的定义

12.9.3 Runtime Semantics: Evaluation

RelationalExpression : RelationalExpression instanceof ShiftExpression

// 执行左边的表达式得到值lval
Let lref be the result of evaluating RelationalExpression.
Let lval be GetValue(lref).
ReturnIfAbrupt(lval).
// 执行右边的表达式得到值rval
Let rref be the result of evaluating ShiftExpression.
Let rval be GetValue(rref).
ReturnIfAbrupt(rval).
// 执行InstanceofOperator
Return InstanceofOperator(lval, rval).

我们接着看InstanceofOperator的定义

12.9.4 Runtime Semantics: InstanceofOperator(O, C)

If Type(C) is not Object, throw a TypeError exception.
// 获取第二个参数的hasInstance方法，赋值给instOfHandler
Let instOfHandler be GetMethod(C,@@hasInstance).
ReturnIfAbrupt(instOfHandler).
// instOfHandler若不是undefined则执行并返回布尔值
If instOfHandler is not undefined, then
Return ToBoolean(Call(instOfHandler, C, «O»)).
If IsCallable(C) is false, throw a TypeError exception.
// 否则执行OrdinaryHasInstance
Return OrdinaryHasInstance(C, O).

最后两个步骤是为了兼容没有内置@@hasInstance方法的ECMAScript版本，其实@@hasInstance中也是执行OrdinaryHasInstance方法。

19.2.3.6 Function.prototype[@@hasInstance] ( V )

Let F be the this value.
// 执行OrdinaryHasInstance
Return OrdinaryHasInstance(F, V).

我们直接看核心方法OrdinaryHasInstance

7.3.19 OrdinaryHasInstance (C, O)

If IsCallable(C) is false, return false.
If C has a [[BoundTargetFunction]] internal slot, then
Let BC be the value of C’s [[BoundTargetFunction]] internal slot.
Return InstanceofOperator(O,BC) (see 12.9.4).
If Type(O) is not Object, return false.
// P指向C的原型
Let P be Get(C, "prototype").
ReturnIfAbrupt(P).
If Type(P) is not Object, throw a TypeError exception.
// 进入循环
Repeat
// O指向O的原型
Let O be O.[[GetPrototypeOf]]().
ReturnIfAbrupt(O).
// 若O为空，返回false
If O is null, return false.
// 若O和P的值相等，返回true
If SameValue(P, O) is true, return true.

官方的定义比较隐晦，我们可以自己很容易地实现一个instanceof函数

let instanceof = (O, C) => {
    let P = C.prototype
    while (true) {
        O = O.__proto__
        if (O === P) return true
        if (O === null) return false
    }
}

其实简单点说就是：对一个实例（左值）从它的原型链中向上进行查找，O.__proto__.__proto__.__proto__...直到找到那个构造函数（右值）的原型C.prototype为止，假如找到的话则返回true，假如找到顶部O.prototype.__proto__还找不到的话返回false。

假如对上面的instanceof函数有疑问的话，别急，我们先回顾一下我们的老朋友——JavaScript原型继承机制。

JavaScript原型继承机制

每个对象都有一个私有属性（称之为 [[Prototype]]），它持有一个连接到另一个称为其 prototype 对象（原型对象）的链接。该 prototype 对象又具有一个自己的原型，层层向上直到一个对象的原型为 null。

遵循ECMAScript标准，someObject.[[Prototype]] 符号是用于指向 someObject的原型。从 ECMAScript 6 开始，[[Prototype]] 可以用Object.getPrototypeOf()和Object.setPrototypeOf()访问器来访问。这个等同于 JavaScript 的非标准但许多浏览器实现的属性 __proto__。

我们再看一张经典原型链的图片

可以看出：

// 创建一个对象实例
o1 = new Object()
// 创建一个函数实例，一般来说不推荐这种方法，这里只是为了方便理解
f1 = new Foo() 

// o1是由Object创建出来的，它的__proto__指向创建它的函数的原型
o1.__proto__ === Object.prototype
// f1是由Foo创建出来的，它的__proto__指向创建它的函数的原型
f1.__proto__ === Foo.prototype

// Foo是个构造函数，也是继承于函数的构造函数Function
Foo.__proto__ === Function.prototype
// Function也是个构造函数，也是继承于他自己
Function.__proto__ === Function.prototype
// 对象也是个构造函数，也是继承于函数的构造函数Function
Object.__proto__ === Function.prototype

// Function.prototype也是一个普通对象，它的__proto__指向对象原型
Function.prototype.__proto__ === Object.prototype
// Foo也是同样的道理
Foo.prototype.__proto__ === Object.prototype

// 对象原型是原型链的顶端，它的__proto__指向null，而null没有__proto__
Object.prototype.__proto__ === null

举个几个栗子

Object instance of Object

R = ObjectR.prototype = Object.prototype
// 第一次判断
L = ObjectL.__proto__ = Function.prototype
// 不等于，进入下一个循环
L != R
// 第二次判断
L = L.__proto__ = Function.prototype.__proto__ = Object.prototype
// 等于，返回true
L == R

Function instance of Function

R = FunctionR.prototype = Function.prototype
// 第一次判断
L = FunctionL.__proto__ = Function.prototype
// 等于，返回true
L == R

Foo instance of Foo

R = FooR.prototype = Foo.prototype
// 第一次判断
L = FooL.__proto__ = Function.prototype
// 不等于，进入下一个循环
L != R
// 第二次判断
L = L.__proto__ = Function.prototype.__proto__ = Object.prototype
// 不等于，进入下一个循环
L != R
// 第三次判断
L = L.__proto__ = Object.prototype.__proto__ = null
// 还是不等于，已经到达原型链顶端，返回false
L != R

举几个特殊的栗子

string instance of String

R = String.prototype = Object.prototype
// 第一次判断
L = string.__proto__ = String.prototype
// 不等于，进入下一个循环
L != R
// 第二次判断
L = L.__proto__ = String.prototype.__proto__ = Object.prototype
// 等于，返回true
L == R

看起来没什么问题，但是实际上

let string = 'test'
string.__proto__ === String.prototype // true
string instance of String // false

这是为什么呢？因为string毕竟还是个字符串，不是对象类型，string有自己的方法是因为ECMAScript提供了3个特殊的引用类型: Boolean、Number 和 String，叫做基本包装类型，而自动创建的基本包装类型的对象只存在于一行代码的执行瞬间然后就立即被销毁。官方并不建议我们显式调用基本包装类型创建对象，这会让人对基本类型和引用类型产生混淆。

看下一个特殊的栗子

null instanceof null // Uncaught TypeError: Right-hand side of 'instanceof' is not an object

undefined instanceof undefined // Uncaught TypeError: Right-hand side of 'instanceof' is not an object

null没有proto方法，严格来说它没有任何属性和方法；undefined不是引用类型，也没有任何属性和方法，在instanceof的语言规范中假如该类型不是引用类型的话则报错。

结语