实例讲解JavaScript中instanceof运算符的用法

instanceof 运算符简介

在 javascript 中，判断一个变量的类型尝尝会用 typeof 运算符，在使用 typeof 运算符时采用引用类型存储值会出现一个问题，无论引用的是什么类型的对象，它都返回 “object”。ecmascript 引入了另一个 java 运算符 instanceof 来解决这个问题。instanceof 运算符与 typeof 运算符相似，用于识别正在处理的对象的类型。与 typeof 方法不同的是，instanceof 方法要求开发者明确地确认对象为某特定类型。例如：

清单 1. instanceof 示例

 var ostringobject = new string("hello world"); 
 console.log(ostringobject instanceof string); // 输出 "true"

这段代码问的是“变量 ostringobject 是否为 string 对象的实例？”ostringobject 的确是 string 对象的实例，因此结果是”true”。尽管不像 typeof 方法那样灵活，但是在 typeof 方法返回 “object” 的情况下，instanceof 方法还是很有用的。

instanceof 运算符的常规用法：

通常来讲，使用 instanceof 就是判断一个实例是否属于某种类型。例如：

清单 2. instanceof 常规用法

 // 判断 foo 是否是 foo 类的实例
 function foo(){} 
 var foo = new foo(); 
 console.log(foo instanceof foo)//true

另外，更重的一点是 instanceof 可以在继承关系中用来判断一个实例是否属于它的父类型。例如：

清单 3. instanceof 在继承中关系中的用法

 // 判断 foo 是否是 foo 类的实例 , 并且是否是其父类型的实例
 function aoo(){} 
 function foo(){} 
 foo.prototype = new aoo();//javascript 原型继承
 
 var foo = new foo(); 
 console.log(foo instanceof foo)//true 
 console.log(foo instanceof aoo)//true

上面的代码中是判断了一层继承关系中的父类，在多层继承关系中，instanceof 运算符同样适用。

你真的了解 instanceof 操作符吗？

看了上面的代码示例，是不是觉得 instanceof 操作符很简单，下面来看点复杂的用法。

清单 4. instanceof 复杂用法

 console.log(object instanceof object);//true 
 console.log(function instanceof function);//true 
 console.log(number instanceof number);//false 
 console.log(string instanceof string);//false 
 
 console.log(function instanceof object);//true 
 
 console.log(foo instanceof function);//true 
 console.log(foo instanceof foo);//false

看了上面的代码是不是又晕头转向了？为什么 object 和 function instanceof 自己等于 true，而其他类 instanceof 自己却又不等于 true 呢？如何解释？要想从根本上了解 instanceof 的奥秘，需要从两个方面着手：1，语言规范中是如何定义这个运算符的。2，javascript 原型继承机制。

清单 5. javascript instanceof 运算符代码

 function instance_of(l, r) {//l 表示左表达式，r 表示右表达式
 var o = r.prototype;// 取 r 的显示原型
 l = l.__proto__;// 取 l 的隐式原型
 while (true) { 
 if (l === null) 
 return false; 
 if (o === l)// 这里重点：当 o 严格等于 l 时，返回 true 
 return true; 
 l = l.__proto__; 
 } 
 }

清单 6. object instanceof object

 // 为了方便表述，首先区分左侧表达式和右侧表达式
 objectl = object, objectr = object; 
 // 下面根据规范逐步推演
 o = objectr.prototype = object.prototype 
 l = objectl.__proto__ = function.prototype 
 // 第一次判断
 o != l 
 // 循环查找 l 是否还有 __proto__ 
 l = function.prototype.__proto__ = object.prototype 
 // 第二次判断
 o == l 
 // 返回 true

清单 7. function instanceof function

 // 为了方便表述，首先区分左侧表达式和右侧表达式
 functionl = function, functionr = function; 
 // 下面根据规范逐步推演
 o = functionr.prototype = function.prototype 
 l = functionl.__proto__ = function.prototype 
 // 第一次判断
 o == l 
 // 返回 true

清单 8. foo instanceof foo

// 为了方便表述，首先区分左侧表达式和右侧表达式
 fool = foo, foor = foo; 
 // 下面根据规范逐步推演
 o = foor.prototype = foo.prototype 
 l = fool.__proto__ = function.prototype 
 // 第一次判断
 o != l 
 // 循环再次查找 l 是否还有 __proto__ 
 l = function.prototype.__proto__ = object.prototype 
 // 第二次判断
 o != l 
 // 再次循环查找 l 是否还有 __proto__ 
 l = object.prototype.__proto__ = null 
 // 第三次判断
 l == null 
 // 返回 false

简析 instanceof 在 dojo 继承机制中的应用

在 javascript 中，是没有多重继承这个概念的，就像 java 一样。但在 dojo 中使用 declare 声明类时，是允许继承自多个类的。下面以 dojo 1.6.1 为例。

清单 9. dojo 中多重继承

 dojo.declare("aoo",null,{}); 
 dojo.declare("boo",null,{}); 
 dojo.declare("foo",[aoo,boo],{}); 
 
 var foo = new foo(); 
 console.log(foo instanceof aoo);//true 
 console.log(foo instanceof boo);//false 
 
 console.log(foo.isinstanceof(aoo));//true 
 console.log(foo.isinstanceof(boo));//true

上面的示例中，foo 同时继承自 aoo 和 boo，但当使用 instanceof 运算符来检查 foo 是否是 boo 的实例时，返回的是 false。实际上，在 dojo 的内部，foo 仍然只继承自 aoo，而通过 mixin 机制把 boo 类中的方法和属性拷贝到 foo 中，所以当用 instanceof 运算符来检查是否是 boo 的实例时，会返回 false。所以 dojo 为每个类的实例添加了一个新的方法叫 isinstanceof，用这个方法来检查多重继承。