对于检测基本数据类型,我们会想到用 typeof 操作符检测;对于引用类型,我们会想到用 instanceof 操作符来检测。通常我们使用它来检测某个值是否是某个类型的实例。
- let person = new Person('eason') person instanceof Person // true
在 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
- }
- }
其实简单点说就是:对一个实例(左值)从它的原型链中向上进行查找,
直到找到那个构造函数(右值)的原型 C.prototype 为止,假如找到的话则返回 true,假如找到顶部
- O.__proto__.__proto__.__proto__...
还找不到的话返回 false。
- O.prototype.__proto__
假如对上面的 instanceof 函数有疑问的话,别急,我们先回顾一下我们的老朋友——JavaScript 原型继承机制。
每个对象都有一个私有属性(称之为 [[Prototype]]),它持有一个连接到另一个称为其 prototype 对象(原型对象)的链接。该 prototype 对象又具有一个自己的原型,层层向上直到一个对象的原型为 null。
遵循 ECMAScript 标准,
符号是用于指向 someObject 的原型。从 ECMAScript 6 开始,[[Prototype]] 可以用
- someObject.[[Prototype]]
访问器来访问。这个等同于 JavaScript 的非标准但许多浏览器实现的属性 __proto__。
- Object.getPrototypeOf()和Object.setPrototypeOf()
我们再看一张经典原型链的图片
可以看出:
- // 创建一个对象实例
- 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
- R = ObjectR.prototype = Object.prototype
- // 第一次判断
- L = ObjectL.__proto__ = Function.prototype
- // 不等于,进入下一个循环
- L != R
- // 第二次判断
- L = L.__proto__ = Function.prototype.__proto__ = Object.prototype
- // 等于,返回true
- L == R
- R = FunctionR.prototype = Function.prototype
- // 第一次判断
- L = FunctionL.__proto__ = Function.prototype
- // 等于,返回true
- L == R
- 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
- 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 的语言规范中假如该类型不是引用类型的话则报错。
来源: http://www.jianshu.com/p/666c2c5767b5