instanceof

instanceof运算符用来测试一个对象在其原型链中是否存在一个构造函数的 prototype 属性。

语法

object instanceof constructor

参数

object要检测的对象.

constructor某个构造函数

描述

instanceof 运算符用来检测 constructor.prototype 是否存在于参数 object 的原型链上。

// defining constructors
function C() {}
function D() {}

var o = new C();

// true, because: Object.getPrototypeOf(o) === C.prototype
o instanceof C;

// false, because D.prototype is nowhere in o's prototype chain
o instanceof D;

o instanceof Object; // true, because:
C.prototype instanceof Object // true

C.prototype = {};
var o2 = new C();

o2 instanceof C; // true

// false, because C.prototype is nowhere in
// o's prototype chain anymore
o instanceof C; 

D.prototype = new C(); // add C to [[Prototype]] linkage of D
var o3 = new D();
o3 instanceof D; // true
o3 instanceof C; // true since C.prototype is now in o3's prototype chain

需要注意的是，如果表达式 obj instanceof Foo 返回true，则并不意味着该表达式会永远返回true，因为Foo.prototype属性的值有可能会改变，改变之后的值很有可能不存在于obj的原型链上，这时原表达式的值就会成为false。另外一种情况下，原表达式的值也会改变，就是改变对象obj的原型链的情况，虽然在目前的ES规范中，我们只能读取对象的原型而不能改变它，但借助于非标准的__proto__魔法属性，是可以实现的。比如执行obj.__proto__ = {}之后，obj instanceof Foo就会返回false了。

instanceof和多全局对象(多个frame或多个window之间的交互)

在浏览器中，我们的脚本可能需要在多个窗口之间进行交互。多个窗口意味着多个全局环境，不同的全局环境拥有不同的全局对象，从而拥有不同的内置类型构造函数。这可能会引发一些问题。比如，表达式 [] instanceof window.frames[0].Array 会返回false，因为 Array.prototype !== window.frames[0].Array.prototype，因此你必须使用 Array.isArray(myObj) 或者 Object.prototype.toString.call(myObj) === "[object Array]"来判断myObj是否是数组。

Mozilla开发者注意:

在代码中使用 XPCOM instanceof 有特殊影响:obj instanceofxpcomInterface(e.g.Components.interfaces.nsIFile) callsobj.QueryInterface(xpcomInterface)and returnstrueif QueryInterface succeeded. A side effect of such call is that you can usexpcomInterface's properties onobjafter a successfulinstanceoftest. Unlike standard JavaScript globals, the testobj instanceof xpcomInterfaceworks as expected even ifobjis from a different scope.

例子

例子: 表明String对象和Date对象都属于Object类型

下面的代码使用了instanceof来证明：String和Date对象同时也属于Object类型。

但是，使用对象文字符号创建的对象在这里是一个例外：虽然原型是未定义的，但instanceof Object返回true。

var simpleStr = 'This is a simple string'; 
var myString  = new String();
var newStr    = new String('String created with constructor');
var myDate    = new Date();
var myObj     = {};

simpleStr instanceof String; // returns false, checks the prototype chain, finds undefined
myString  instanceof String; // returns true
newStr    instanceof String; // returns true
myString  instanceof Object; // returns true

myObj instanceof Object;    // returns true, despite an undefined prototype
({})  instanceof Object;    // returns true, same case as above

myString instanceof Date;   // returns false

myDate instanceof Date;     // returns true
myDate instanceof Object;   // returns true
myDate instanceof String;   // returns false

演示mycar属于Car类型的同时又属于Object类型

下面的代码创建了一个类型Car，以及该类型的对象实例mycar. instanceof运算符表明了这个mycar对象既属于Car类型，又属于Object类型。

function Car(make, model, year) {
  this.make = make;
  this.model = model;
  this.year = year;
}
var mycar = new Car('Honda', 'Accord', 1998);
var a = mycar instanceof Car;    // returns true
var b = mycar instanceof Object; // returns true

规范

Specification	Status	Comment
ECMAScript Latest Draft (ECMA-262)The definition of 'Relational Operators' in that specification.	Living Standard	​
ECMAScript 2015 (6th Edition, ECMA-262)The definition of 'Relational Operators' in that specification.	Standard	​
ECMAScript 5.1 (ECMA-262)The definition of 'The instanceof operator' in that specification.	Standard	​
ECMAScript 3rd Edition (ECMA-262)The definition of 'The instanceof operator' in that specification.	Standard	Initial definition. Implemented in JavaScript 1.4.

浏览器兼容性

Feature	Chrome	Edge	Firefox (Gecko)	Internet Explorer	Opera	Safari
Basic support	(Yes)	(Yes)	(Yes)	(Yes)	(Yes)	(Yes)

Feature	Android	Chrome for Android	Edge	Firefox Mobile (Gecko)	IE Mobile	Opera Mobile	Safari Mobile
Basic support	(Yes)	(Yes)	(Yes)	(Yes)	(Yes)	(Yes)	(Yes)