blocks|key|1283067|text|实例数|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1283068|左手侧(LHS)操作数是被测试到右侧(RHS)操作数的实际对象，RHS操作数是类的实际构造函数。基本定义是：|1283069|检查当前对象，如果对象是指定的对象类型，则返回true。|blockquote|1283070|下面是一些好例子，下面是直接从Mozilla的开发人员站点获取的一个例子|offset|length|1283071|var+color1+=+new+String("green");
color1+instanceof+String;+//+returns+true
var+color2+=+"coral";+//no+type+specified
color2+instanceof+String;+//+returns+false+(color2+is+not+a+String+object)|code-block|syntax|javascript|1283072|值得一提的是，如果对象继承自类的原型，则instanceof计算结果为true：|style|CODE|1283073|var+p+=+new+Person("Jon");
p+instanceof+Person|1283074|这是p+instanceof+Person，因为p是从Person.prototype继承的。|1283075|根据任择议定书的要求|1283076|我添加了一个小示例，并给出了一些示例代码和说明。|1283077|当您声明一个变量时，就给它一个特定的类型。|1283078|例如：|1283079|int+i;
float+f;
Customer+c;|1283080|上面向您展示了一些变量，即i、f和c。这些类型是integer、float和用户定义的Customer数据类型。像上面这样的类型可以用于任何语言，而不仅仅是JavaScript。但是，在JavaScript中，当您声明一个变量时，您没有显式地定义一个类型，var+x，x可以是一个数字/字符串/用户定义的数据类型。因此，instanceof所做的是检查对象，看看它是否属于指定的类型，因此从上面取下Customer对象，我们可以这样做：|1283081|var+c+=+new+Customer();
c+instanceof+Customer;+//Returns+true+as+c+is+just+a+customer
c+instanceof+String;+//Returns+false+as+c+is+not+a+string,+it's+a+customer+silly!|1283082|上面我们已经看到c是用Customer类型声明的。我们对它做了新的修改，并检查了它是否是Customer型的。当然，它返回的是真。然后仍然使用Customer对象来检查它是否是String。不，绝对不是String+--我们更新了一个Customer对象，而不是一个String对象。在这种情况下，它返回false。|1283083|真的很简单！|1283084|entityMap|0|LINK|mutability|MUTABLE|url|http://www.herongyang.com/JavaScript/Prototype-instanceof-Operator-Determine-Object-Type.html|1|https://developer.mozilla.org/En/Core_JavaScript_1.5_Reference/Operators/Special_Operators/Instanceof_Operator^0|0|0|0|5|3|0|F|E|1|0|0|K|A|0|0|2|J|O|1|R|G|0|0|0|0|0|0|D|1|F|1|H|1|O|7|W|5|17|8|3K|5|4G|A|5J|8|0|0|8|1|B|8|18|8|1Z|8|2G|6|2T|6|39|8|3P|6|0|0^^$0|@$1|2|3|4|5|6|7|1P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1R|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|1S|8|@]|9|@$I|1T|J|1U|1|1V]|$I|1W|J|1X|1|1Y]]|A|$]]|$1|K|3|L|5|M|7|1Z|8|@]|9|@]|A|$N|O]]|$1|P|3|Q|5|6|7|20|8|@$I|21|J|22|R|S]]|9|@]|A|$]]|$1|T|3|U|5|M|7|23|8|@]|9|@]|A|$N|O]]|$1|V|3|W|5|6|7|24|8|@$I|25|J|26|R|S]|$I|27|J|28|R|S]|$I|29|J|2A|R|S]]|9|@]|A|$]]|$1|X|3|Y|5|6|7|2B|8|@]|9|@]|A|$]]|$1|Z|3|10|5|6|7|2C|8|@]|9|@]|A|$]]|$1|11|3|12|5|6|7|2D|8|@]|9|@]|A|$]]|$1|13|3|14|5|6|7|2E|8|@]|9|@]|A|$]]|$1|15|3|16|5|M|7|2F|8|@]|9|@]|A|$N|O]]|$1|17|3|18|5|6|7|2G|8|@$I|2H|J|2I|R|S]|$I|2J|J|2K|R|S]|$I|2L|J|2M|R|S]|$I|2N|J|2O|R|S]|$I|2P|J|2Q|R|S]|$I|2R|J|2S|R|S]|$I|2T|J|2U|R|S]|$I|2V|J|2W|R|S]|$I|2X|J|2Y|R|S]]|9|@]|A|$]]|$1|19|3|1A|5|M|7|2Z|8|@]|9|@]|A|$N|O]]|$1|1B|3|1C|5|6|7|30|8|@$I|31|J|32|R|S]|$I|33|J|34|R|S]|$I|35|J|36|R|S]|$I|37|J|38|R|S]|$I|39|J|3A|R|S]|$I|3B|J|3C|R|S]|$I|3D|J|3E|R|S]|$I|3F|J|3G|R|S]]|9|@]|A|$]]|$1|1D|3|1E|5|6|7|3H|8|@]|9|@]|A|$]]|$1|1F|3|-4|5|6|7|3I|8|@]|9|@]|A|$]]]|1G|$1H|$5|1I|1J|1K|A|$1L|1M]]|1N|$5|1I|1J|1K|A|$1L|1O]]]]

<h1>instanceof</h1>
The Left Hand Side (LHS) operand is the actual object being tested to the Right Hand Side (RHS) operand which is the actual constructor of a class. The basic definition is:
<blockquote>
Checks the current object and returns true if the object is of the specified object type.
</blockquote>
Here are some <a href="http://www.herongyang.com/JavaScript/Prototype-instanceof-Operator-Determine-Object-Type.html" rel="noreferrer">good examples</a> and here is an example taken directly from <a href="https://developer.mozilla.org/En/Core_JavaScript_1.5_Reference/Operators/Special_Operators/Instanceof_Operator" rel="noreferrer">Mozilla's developer site</a>:
<pre><code>var color1 = new String(&quot;green&quot;);
color1 instanceof String; // returns true
var color2 = &quot;coral&quot;; //no type specified
color2 instanceof String; // returns false (color2 is not a String object)
</code></pre>
One thing worth mentioning is <code>instanceof</code> evaluates to true if the object inherits from the class's prototype:
<pre><code>var p = new Person(&quot;Jon&quot;);
p instanceof Person
</code></pre>
That is <code>p instanceof Person</code> is true since <code>p</code> inherits from <code>Person.prototype</code>.
<h3>Per the OP's request</h3>
I've added a small example with some sample code and an explanation. 
When you declare a variable you give it a specific type.
For instance:
<pre><code>int i;
float f;
Customer c;
</code></pre>
The above show you some variables, namely <code>i</code>, <code>f</code>, and <code>c</code>. The types are <code>integer</code>, <code>float</code> and a user defined <code>Customer</code> data type. Types such as the above could be for any language, not just JavaScript. However, with JavaScript when you declare a variable you don't explicitly define a type, <code>var x</code>, x could be a number / string / a user defined data type. So what <code>instanceof</code> does is it checks the object to see if it is of the type specified so from above taking the <code>Customer</code> object we could do:
<pre><code>var c = new Customer();
c instanceof Customer; //Returns true as c is just a customer
c instanceof String; //Returns false as c is not a string, it's a customer silly!
</code></pre>
Above we've seen that <code>c</code> was declared with the type <code>Customer</code>. We've new'd it and checked whether it is of type <code>Customer</code> or not. Sure is, it returns true. Then still using the <code>Customer</code> object we check if it is a <code>String</code>. Nope, definitely not a <code>String</code> we newed a <code>Customer</code> object not a <code>String</code> object. In this case, it returns false.
It really is that simple!

blocks|key|1281463|text|//Vehicle+is+a+function.+But+by+naming+conventions
//(first+letter+is+uppercase),+it+is+also+an+object
//constructor+function+("class").
function+Vehicle(numWheels)+{
++++this.numWheels+=+numWheels;
}

//We+can+create+new+instances+and+check+their+types.
myRoadster+=+new+Vehicle(4);
alert(myRoadster+instanceof+Vehicle);|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1281464|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>//Vehicle is a function. But by naming conventions
//(first letter is uppercase), it is also an object
//constructor function ("class").
function Vehicle(numWheels) {
 this.numWheels = numWheels;
}

//We can create new instances and check their types.
myRoadster = new Vehicle(4);
alert(myRoadster instanceof Vehicle);
</code></pre>

blocks|key|3028169|text|我认为值得注意的是，instanceof是通过在声明对象时使用"new“关键字定义的。在JonH的例子中；|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3028170|var+color1+=+new+String("green");
color1+instanceof+String;+//+returns+true
var+color2+=+"coral";
color2+instanceof+String;+//+returns+false+(color2+is+not+a+String+object)|code-block|syntax|javascript|3028171|他没提到的是这个；|3028172|var+color1+=+String("green");
color1+instanceof+String;+//+returns+false|3028173|指定"new“实际上将字符串构造函数的结束状态复制到color1变量中，而不仅仅是将其设置为返回值。我认为这更好地显示了新关键字的作用；|3028174|function+Test(name){
++++this.test+=+function(){
++++++++return+'This+will+only+work+through+the+"new"+keyword.';
++++}
++++return+name;
}

var+test+=+new+Test('test');
test.test();+//+returns+'This+will+only+work+through+the+"new"+keyword.'
test+//+returns+the+instance+object+of+the+Test()+function.

var+test+=+Test('test');
test.test();+//+throws+TypeError:+Object+#<Test>+has+no+method+'test'
test+//+returns+'test'|3028175|使用"new“在函数中将"this”的值赋值给声明的var，而不使用它则分配返回值。|3028176|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

I think it's worth noting that instanceof is defined by the use of the "new" keyword when declaring the object. In the example from JonH;

<pre><code>var color1 = new String("green");
color1 instanceof String; // returns true
var color2 = "coral";
color2 instanceof String; // returns false (color2 is not a String object)
</code></pre>

What he didn't mention is this;

<pre><code>var color1 = String("green");
color1 instanceof String; // returns false
</code></pre>

Specifying "new" actually copied the end state of the String constructor function into the color1 var, rather than just setting it to the return value. I think this better shows what the new keyword does;

<pre><code>function Test(name){
 this.test = function(){
 return 'This will only work through the "new" keyword.';
 }
 return name;
}

var test = new Test('test');
test.test(); // returns 'This will only work through the "new" keyword.'
test // returns the instance object of the Test() function.

var test = Test('test');
test.test(); // throws TypeError: Object #&lt;Test&gt; has no method 'test'
test // returns 'test'
</code></pre>

Using "new" assigns the value of "this" inside the function to the declared var, while not using it assigns the return value instead.

blocks|key|1283097|text|您可以使用它进行错误处理和调试，如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1283098|try{
++++somefunction();
}+
catch(error){
++++if+(error+instanceof+TypeError)+{
++++++++//+Handle+type+Error
++++}+else+if+(error+instanceof+ReferenceError)+{
++++++++//+Handle+ReferenceError
++++}+else+{
++++++++//+Handle+all+other+error+types
++++}
}|code-block|syntax|javascript|1283099|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

And you can use it for error handling and debugging, like this:

<pre><code>try{
 somefunction();
} 
catch(error){
 if (error instanceof TypeError) {
 // Handle type Error
 } else if (error instanceof ReferenceError) {
 // Handle ReferenceError
 } else {
 // Handle all other error types
 }
}
</code></pre>

blocks|key|1504540|text|到目前为止，任何评论似乎都没有涉及到其中一个重要的方面:继承。由于原型继承，通过使用instanceof计算的变量可以返回多个“类型”的true。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1504541|例如，让我们定义一个类型和一个子类型：|1504542|function+Foo(){+//a+Foo+constructor
++++//assign+some+props
++++return+this;
}

function+SubFoo(){+//a+SubFoo+constructor
++++Foo.call(+this+);+//inherit+static+props
++++//assign+some+new+props
++++return+this;
}

SubFoo.prototype+=+Object.create(Foo.prototype);+//+Inherit+prototype
SubFoo.prototype.constructor+=+SubFoo;|code-block|syntax|javascript|1504543|现在我们有了几个“类”，让我们创建一些实例，并找出它们是哪些实例：|1504544|var+
++++foo+=+new+Foo()
,+++subfoo+=+new+SubFoo()
;

alert(+
++++"Q:+Is+foo+an+instance+of+Foo?+"
%2B+++"A:+"+%2B+(+foo+instanceof+Foo+)+
);+//+->+true

alert(+
++++"Q:+Is+foo+an+instance+of+SubFoo?+"+
%2B+++"A:+"+%2B+(+foo+instanceof+SubFoo+)+
);+//+->+false

alert(+
++++"Q:+Is+subfoo+an+instance+of+Foo?+"
%2B+++"A:+"+%2B+(+subfoo+instanceof+Foo+)+
);+//+->+true

alert(+
++++"Q:+Is+subfoo+an+instance+of+SubFoo?+"
%2B+++"A:+"+%2B+(+subfoo+instanceof+SubFoo+)+
);+//+->+true

alert(+
++++"Q:+Is+subfoo+an+instance+of+Object?+"
%2B+++"A:+"+%2B+(+subfoo+instanceof+Object+)+
);+//+->+true|1504545|看到最后一行了吗？所有对函数的“新”调用都返回继承自对象的对象。即使使用对象创建速记，这也是正确的：|1504546|alert(+
++++"Q:+Is+{}+an+instance+of+Object?+"
%2B+++"A:+"+%2B+(+{}+instanceof+Object+)+
);+//+->+true|1504547|那么“类”定义本身又如何呢？他们的例子是什么？|1504548|alert(+
++++"Q:+Is+Foo+an+instance+of+Object?+"
%2B+++"A:"+%2B+(+Foo+instanceof+Object)+
);+//+->+true

alert(+
++++"Q:+Is+Foo+an+instance+of+Function?+"
%2B+++"A:"+%2B+(+Foo+instanceof+Function)+
);+//+->+true|1504549|我认为理解任何对象都可以是多个类型的实例是很重要的，因为您可以(错误地)假设您可以通过使用instanceof来区分对象和函数。正如最后一个例子清楚地显示的那样，函数是一个对象。|offset|length|style|CODE|1504550|如果您正在使用任何继承模式，并且希望通过鸭类型以外的方法来确认对象的后代，这一点也很重要。|1504551|希望这对探索instanceof的人有帮助。|1504552|entityMap^0|0|0|0|0|0|0|0|0|0|19|A|0|0|6|A|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|17|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|18|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|19|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|1A|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|1B|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|1C|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|1D|8|@]|9|@]|A|$]]|$1|S|3|T|5|F|7|1E|8|@]|9|@]|A|$G|H]]|$1|U|3|V|5|6|7|1F|8|@$W|1G|X|1H|Y|Z]]|9|@]|A|$]]|$1|10|3|11|5|6|7|1I|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|1J|8|@$W|1K|X|1L|Y|Z]]|9|@]|A|$]]|$1|14|3|-4|5|6|7|1M|8|@]|9|@]|A|$]]]|15|$]]

There's an important facet to instanceof that does not seem to be covered in any of the comments thus far: inheritance. A variable being evaluated by use of instanceof could return true for multiple "types" due to prototypal inheritance.

For example, let's define a type and a subtype:

<pre><code>function Foo(){ //a Foo constructor
 //assign some props
 return this;
}

function SubFoo(){ //a SubFoo constructor
 Foo.call( this ); //inherit static props
 //assign some new props
 return this;
}

SubFoo.prototype = Object.create(Foo.prototype); // Inherit prototype
SubFoo.prototype.constructor = SubFoo;
</code></pre>

Now that we have a couple of "classes" lets make some instances, and find out what they're instances of:

<pre><code>var 
 foo = new Foo()
, subfoo = new SubFoo()
;

alert( 
 "Q: Is foo an instance of Foo? "
+ "A: " + ( foo instanceof Foo ) 
); // -&gt; true

alert( 
 "Q: Is foo an instance of SubFoo? " 
+ "A: " + ( foo instanceof SubFoo ) 
); // -&gt; false

alert( 
 "Q: Is subfoo an instance of Foo? "
+ "A: " + ( subfoo instanceof Foo ) 
); // -&gt; true

alert( 
 "Q: Is subfoo an instance of SubFoo? "
+ "A: " + ( subfoo instanceof SubFoo ) 
); // -&gt; true

alert( 
 "Q: Is subfoo an instance of Object? "
+ "A: " + ( subfoo instanceof Object ) 
); // -&gt; true
</code></pre>

See that last line? All "new" calls to a function return an object that inherits from Object. This holds true even when using object creation shorthand:

<pre><code>alert( 
 "Q: Is {} an instance of Object? "
+ "A: " + ( {} instanceof Object ) 
); // -&gt; true
</code></pre>

And what about the "class" definitions themselves? What are they instances of?

<pre><code>alert( 
 "Q: Is Foo an instance of Object? "
+ "A:" + ( Foo instanceof Object) 
); // -&gt; true

alert( 
 "Q: Is Foo an instance of Function? "
+ "A:" + ( Foo instanceof Function) 
); // -&gt; true
</code></pre>

I feel that understanding that any object can be an instance of MULTIPLE types is important, since you my (incorrectly) assume that you could differentiate between, say and object and a function by use of <code>instanceof</code>. As this last example clearly shows a function is an object.

This is also important if you are using any inheritance patterns and want to confirm the progeny of an object by methods other than duck-typing. 

Hope that helps anyone exploring <code>instanceof</code>.

blocks|key|1504599|text|这里的其他答案是正确的，但它们没有深入了解instanceof的实际工作方式，这可能会引起一些语言律师的兴趣。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1504600|JavaScript中的每个对象都有一个原型，可以通过__proto__属性访问。函数还有一个prototype属性，它是它们创建的任何对象的初始__proto__。在创建函数时，将为prototype提供一个唯一的对象。instanceof运算符使用此唯一性给您一个答案。如果您将instanceof作为一个函数编写，下面是它的样子。|1504601|function+instance_of(V,+F)+{
++var+O+=+F.prototype;
++V+=+V.__proto__;
++while+(true)+{
++++if+(V+===+null)
++++++return+false;
++++if+(O+===+V)
++++++return+true;
++++V+=+V.__proto__;
++}
}|code-block|syntax|javascript|1504602|这基本上是翻译ECMA-262版5.1+(也称为ES5)，第15.3.5.3节.|1504603|注意，您可以将任何对象重新分配到函数的prototype属性，也可以在构造对象的__proto__属性之后重新分配它。这将给你一些有趣的结果：|1504604|function+F()+{+}
function+G()+{+}
var+p+=+{};
F.prototype+=+p;
G.prototype+=+p;
var+f+=+new+F();
var+g+=+new+G();

f+instanceof+F;+++//+returns+true
f+instanceof+G;+++//+returns+true
g+instanceof+F;+++//+returns+true
g+instanceof+G;+++//+returns+true

F.prototype+=+{};
f+instanceof+F;+++//+returns+false
g.__proto__+=+{};
g+instanceof+G;+++//+returns+false|1504605|entityMap^0|L|A|0|R|9|1B|9|21|9|2K|9|33|A|3X|A|0|0|0|J|9|14|9|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@$9|Y|A|Z|B|C]|$9|10|A|11|B|C]|$9|12|A|13|B|C]|$9|14|A|15|B|C]|$9|16|A|17|B|C]|$9|18|A|19|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|1A|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1B|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|1C|8|@$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|J|7|1H|8|@]|D|@]|E|$K|L]]|$1|S|3|-4|5|6|7|1I|8|@]|D|@]|E|$]]]|T|$]]

The other answers here are correct, but they don't get into how <code>instanceof</code> actually works, which may be of interest to some language lawyers out there.

Every object in JavaScript has a prototype, accessible through the <code>__proto__</code> property. Functions also have a <code>prototype</code> property, which is the initial <code>__proto__</code> for any objects created by them. When a function is created, it is given a unique object for <code>prototype</code>. The <code>instanceof</code> operator uses this uniqueness to give you an answer. Here's what <code>instanceof</code> might look like if you wrote it as a function.

<pre><code>function instance_of(V, F) {
 var O = F.prototype;
 V = V.__proto__;
 while (true) {
 if (V === null)
 return false;
 if (O === V)
 return true;
 V = V.__proto__;
 }
}
</code></pre>

This is basically paraphrasing ECMA-262 edition 5.1 (also known as ES5), section 15.3.5.3. 

Note that you can reassign any object to a function's <code>prototype</code> property, and you can reassign an object's <code>__proto__</code> property after it is constructed. This will give you some interesting results:

<pre><code>function F() { }
function G() { }
var p = {};
F.prototype = p;
G.prototype = p;
var f = new F();
var g = new G();

f instanceof F; // returns true
f instanceof G; // returns true
g instanceof F; // returns true
g instanceof G; // returns true

F.prototype = {};
f instanceof F; // returns false
g.__proto__ = {};
g instanceof G; // returns false
</code></pre>

blocks|key|1281512|text|关于“什么时候合适，什么时候不合适？”，我的2分钱：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1281513|instanceof在生产代码中很少有用，但是在您希望断言代码返回/创建正确类型的对象的测试中很有用。通过明确说明代码返回/创建的对象类型，您的测试作为理解和记录代码的工具变得更加强大。|offset|length|style|CODE|1281514|entityMap^0|0|0|A|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

On the question "When is it appropriate and when not?", my 2 cents:

<code>instanceof</code> is rarely useful in production code, but useful in tests where you want to assert that your code returns / creates objects of the correct types. By being explicit about the kinds of objects your code is returning / creating, your tests become more powerful as a tool for understanding and documenting your code.

blocks|key|1504621|text|我刚刚找到了一个现实世界的应用程序，我想我现在会更经常地使用它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1504622|如果您使用jQuery事件，有时您希望编写一个更通用的函数，这个函数也可以直接调用(没有事件)。您可以使用instanceof检查函数的第一个参数是否是jQuery.Event的实例，并作出适当的反应。|offset|length|style|CODE|1504623|var+myFunction+=+function+(el)+{++++++++++++++++
++++if+(el+instanceof+$.Event)+
++++++++//+event+specific+code
++++else
++++++++//+generic+code
};

$('button').click(recalc);++++//+Will+execute+event+specific+code
recalc('myParameter');++//+Will+execute+generic+code|code-block|syntax|javascript|1504624|在我的示例中，函数需要计算所有元素(通过按钮上的单击事件)或只计算一个特定元素。我使用的代码：|1504625|var+recalc+=+function+(el)+{+
++++el+=+(el+==+undefined+%7C%7C+el+instanceof+$.Event)+?+$('span.allItems')+:+$(el);
++++//+calculate...
};|1504626|entityMap^0|0|1H|A|24|C|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@$D|U|E|V|F|G]|$D|W|E|X|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|Y|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|10|8|@]|9|@]|A|$K|L]]|$1|Q|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|R|$]]

I just found a real-world application and will use it more often now, I think.

If you use jQuery events, sometimes you want to write a more generic function which may also be called directly (without event). You can use <code>instanceof</code> to check if the first parameter of your function is an instance of <code>jQuery.Event</code> and react appropriately.

<pre><code>var myFunction = function (el) { 
 if (el instanceof $.Event) 
 // event specific code
 else
 // generic code
};

$('button').click(recalc); // Will execute event specific code
recalc('myParameter'); // Will execute generic code
</code></pre>

In my case, the function needed to calculate something either for all (via click event on a button) or only one specific element. The code I used:

<pre><code>var recalc = function (el) { 
 el = (el == undefined || el instanceof $.Event) ? $('span.allItems') : $(el);
 // calculate...
};
</code></pre>

blocks|key|1283159|text|instanceof只是isPrototypeOf的语法糖|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1283160|function+Ctor()+{}
var+o+=+new+Ctor();

o+instanceof+Ctor;+//+true
Ctor.prototype.isPrototypeOf(o);+//+true

o+instanceof+Ctor+===+Ctor.prototype.isPrototypeOf(o);+//+equivalent|code-block|syntax|javascript|1283161|instanceof只依赖于对象的构造函数的原型。|1283162|构造函数只是一个正常的函数。严格地说，它是一个函数对象，因为所有东西都是Javascript中的一个对象。这个函数对象有一个原型，因为每个函数都有一个原型。|1283163|原型只是一个普通的对象，它位于另一个对象的原型链中。这意味着在另一个对象的原型链中，将一个对象变成一个原型：|1283164|function+f()+{}+//++ordinary+function
var+o+=+{},+//+ordinary+object
+p;

f.prototype+=+o;+//+oops,+o+is+a+prototype+now
p+=+new+f();+//+oops,+f+is+a+constructor+now

o.isPrototypeOf(p);+//+true
p+instanceof+f;+//+true|1283165|应该避免使用instanceof操作符，因为它伪造了Javascript中不存在的类。尽管class关键字在ES2015中也没有，因为class再次只是语法糖for...but，这就另当别论了。|1283166|entityMap^0|0|A|C|D|0|0|0|A|0|0|0|0|6|A|19|5|1V|5|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|15|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|16|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|17|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|18|8|@$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]]|D|@]|E|$]]|$1|U|3|-4|5|6|7|1F|8|@]|D|@]|E|$]]]|V|$]]

<code>instanceof</code> is just syntactic sugar for <code>isPrototypeOf</code>:

<pre><code>function Ctor() {}
var o = new Ctor();

o instanceof Ctor; // true
Ctor.prototype.isPrototypeOf(o); // true

o instanceof Ctor === Ctor.prototype.isPrototypeOf(o); // equivalent
</code></pre>

<code>instanceof</code> just depends on the prototype of a constructor of an object.

A constructor is just a normal function. Strictly speaking it is a function object, since everything is an object in Javascript. And this function object has a prototype, because every function has a prototype.

A prototype is just a normal object, which is located within the prototype chain of another object. That means being in the prototype chain of another object makes an object to a prototype:

<pre><code>function f() {} // ordinary function
var o = {}, // ordinary object
 p;

f.prototype = o; // oops, o is a prototype now
p = new f(); // oops, f is a constructor now

o.isPrototypeOf(p); // true
p instanceof f; // true
</code></pre>

The <code>instanceof</code> operator should be avoided because it fakes classes, which do not exist in Javascript. Despite the <code>class</code> keyword not in ES2015 either, since <code>class</code> is again just syntactic sugar for...but that's another story.

blocks|key|3028388|text|那是什么？|type|blockquote|depth|inlineStyleRanges|entityRanges|data|3028389|Javascript是一种原型语言，这意味着它使用原型进行“继承”。instanceof运算符测试一个构造函数的prototype属性类型是否存在于对象的__proto__链中。这意味着它将执行以下操作(假设testObj是一个函数对象)：|unstyled|offset|length|style|CODE|3028390|obj+instanceof+testObj;|code-block|syntax|javascript|3028391|检查对象的原型是否等于构造函数的原型：obj.__proto__+===+testObj.prototype+>>(如果这是true+instanceof将返回true+)。|ordered-list-item|3028392|会爬上原型链。例如：obj.__proto__.__proto__+===+testObj.prototype+>>(如果这是true+instanceof+)将返回true。|3028393|将重复步骤2，直到检查对象的完整原型为止。如果在对象的原型链上没有任何地方与testObj.prototype匹配，那么instanceof操作符将返回false。|3028394|示例：|3028395|​|3028396|function+Person(name)+{
++this.name+=+name;
}
var+me+=+new+Person('Willem');

console.log(me+instanceof+Person);+//+true
//+because:++me.__proto__+===+Person.prototype++//+evaluates+true

console.log(me+instanceof+Object);+//+true
//+because:++me.__proto__.__proto__+===+Object.prototype++//+evaluates+true

console.log(me+instanceof+Array);++//+false
//+because:+Array+is+nowhere+on+the+prototype+chain|3028397|3028398|它解决了哪些问题？|3028399|它解决了方便地检查一个对象是否来自某个原型的问题。例如，当一个函数接收一个可以具有各种原型的对象时。然后，在使用原型链的方法之前，我们可以使用instanceof操作符来检查这些方法是否在对象上。|3028400|3028401|3028402|function+Person1+(name)+{
++this.name+=+name;
}

function+Person2+(name)+{
++this.name+=+name;
}

Person1.prototype.talkP1+=+function+()+{
++console.log('Person+1+talking');
}

Person2.prototype.talkP2+=+function+()+{
++console.log('Person+2+talking');
}


function+talk+(person)+{
++if+(person+instanceof+Person1)+{
++++person.talkP1();
++}
++
++if+(person+instanceof+Person2)+{
++++person.talkP2();
++}
++
++
}

const+pers1+=+new+Person1+('p1');
const+pers2+=+new+Person2+('p2');

talk(pers1);
talk(pers2);|3028403|3028404|这里，在talk()函数中，首先检查原型是否位于对象上。在此之后，选择适当的方法来执行。不执行此检查可能导致执行不存在的方法，从而导致引用错误。|3028405|什么时候合适，什么时候不合适？|3028406|我们已经讨论过了。当您需要检查对象的原型时使用它，然后再使用它。|3028407|entityMap^0|0|Y|A|1K|9|25|9|0|0|J|Z|1Q|4|1V|A|28|4|0|A|19|1R|4|1W|A|2B|4|0|12|H|1O|A|24|5|0|0|0|0|0|0|1Z|A|0|0|0|0|0|4|6|0|0|0^^$0|@$1|2|3|4|5|6|7|1I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1J|8|@$E|1K|F|1L|G|H]|$E|1M|F|1N|G|H]|$E|1O|F|1P|G|H]]|9|@]|A|$]]|$1|I|3|J|5|K|7|1Q|8|@]|9|@]|A|$L|M]]|$1|N|3|O|5|P|7|1R|8|@$E|1S|F|1T|G|H]|$E|1U|F|1V|G|H]|$E|1W|F|1X|G|H]|$E|1Y|F|1Z|G|H]]|9|@]|A|$]]|$1|Q|3|R|5|P|7|20|8|@$E|21|F|22|G|H]|$E|23|F|24|G|H]|$E|25|F|26|G|H]|$E|27|F|28|G|H]]|9|@]|A|$]]|$1|S|3|T|5|P|7|29|8|@$E|2A|F|2B|G|H]|$E|2C|F|2D|G|H]|$E|2E|F|2F|G|H]]|9|@]|A|$]]|$1|U|3|V|5|D|7|2G|8|@]|9|@]|A|$]]|$1|W|3|X|5|D|7|2H|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|K|7|2I|8|@]|9|@]|A|$L|M]]|$1|10|3|X|5|D|7|2J|8|@]|9|@]|A|$]]|$1|11|3|12|5|6|7|2K|8|@]|9|@]|A|$]]|$1|13|3|14|5|D|7|2L|8|@$E|2M|F|2N|G|H]]|9|@]|A|$]]|$1|15|3|V|5|D|7|2O|8|@]|9|@]|A|$]]|$1|16|3|X|5|D|7|2P|8|@]|9|@]|A|$]]|$1|17|3|18|5|K|7|2Q|8|@]|9|@]|A|$L|M]]|$1|19|3|X|5|D|7|2R|8|@]|9|@]|A|$]]|$1|1A|3|1B|5|D|7|2S|8|@$E|2T|F|2U|G|H]]|9|@]|A|$]]|$1|1C|3|1D|5|6|7|2V|8|@]|9|@]|A|$]]|$1|1E|3|1F|5|D|7|2W|8|@]|9|@]|A|$]]|$1|1G|3|-4|5|D|7|2X|8|@]|9|@]|A|$]]]|1H|$]]

<blockquote>
 What is it?
</blockquote>

Javascript is a prototypal language which means it uses prototypes for 'inheritance'. the <code>instanceof</code> operator tests if a constructor function's <code>prototype</code> propertype is present in the <code>__proto__</code> chain of an object. This means that it will do the following (assuming that testObj is a function object):

<pre><code>obj instanceof testObj;
</code></pre>

<ol>
<li>Check if prototype of the object is equal to the prototype of the constructor: <code>obj.__proto__ === testObj.prototype</code> >> if this is <code>true</code> <code>instanceof</code> will return <code>true</code>.</li>
<li>Will climb up the prototype chain. For example: <code>obj.__proto__.__proto__ === testObj.prototype</code> >> if this is <code>true</code> <code>instanceof</code> will return <code>true</code>.</li>
<li>Will repeat step 2 until the full prototype of object is inspected. If nowhere on the prototype chain of the object is matched with <code>testObj.prototype</code> then <code>instanceof</code> operator will return <code>false</code>.</li>
</ol>

<h2>Example:</h2>

<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>function Person(name) {
 this.name = name;
}
var me = new Person('Willem');

console.log(me instanceof Person); // true
// because: me.__proto__ === Person.prototype // evaluates true

console.log(me instanceof Object); // true
// because: me.__proto__.__proto__ === Object.prototype // evaluates true

console.log(me instanceof Array); // false
// because: Array is nowhere on the prototype chain</code></pre>
</div>
</div>


<blockquote>
 What problems does it solve? 
</blockquote>

It solved the problem of conveniently checking if an object derives from a certain prototype. For example, when a function recieves an object which can have various prototypes. Then, before using methods from the prototype chain, we can use the <code>instanceof</code> operator to check whether the these methods are on the object.

<h2>Example:</h2>

<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>function Person1 (name) {
 this.name = name;
}

function Person2 (name) {
 this.name = name;
}

Person1.prototype.talkP1 = function () {
 console.log('Person 1 talking');
}

Person2.prototype.talkP2 = function () {
 console.log('Person 2 talking');
}


function talk (person) {
 if (person instanceof Person1) {
 person.talkP1();
 }
 
 if (person instanceof Person2) {
 person.talkP2();
 }
 
 
}

const pers1 = new Person1 ('p1');
const pers2 = new Person2 ('p2');

talk(pers1);
talk(pers2);</code></pre>
</div>
</div>


Here in the <code>talk()</code> function first is checked if the prototype is located on the object. After this the appropriate method is picked to execute. Not doing this check could result in executing a method which doesn't exist and thus a reference error.

<blockquote>
 When is it appropriate and when not?
</blockquote>

We kind of already went over this. Use it when you are in need of checking the prototype of an object before doing something with it.

blocks|key|1281566|text|@SebastianSimon我的最后一个答案是8岁(当我跛足的时候)，有可能我写了一些公牛*hit+:)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1281567|简单地说-目前我使用instanceof的唯一情况是使用class实例，行为取决于我将接收的类，例如。我想区分一下，如果404是ErrorA(资源不存在)还是ErrorB(服务未找到)--库响应代码令人困惑，但幸运的是，它使用了不同的错误类。|offset|length|style|CODE|1281568|肯定(目前)我不会使用它来检查反映原语的类型--您不能确定库是返回'msg'还是new+String('msg')。|BOLD|1281569|它们都有属于String类的方法，因为'msg'原语在内部包装成string对象。内部指的是翻译。他们都是Strings，但instanceof操作符在这里似乎是不够的--检查一下是否有什么东西。是原语或类，我将使用typeof+&&+instanceof的混合，但只用于从外部JS库返回的内容。|1281570|Currenlty正在解决这个问题，您不再需要使用typeof和instanceof这样的严格检查。|1281571|entityMap^0|0|A|A|S|5|0|0|1M|X|5|14|H|0|0|44|6|6|J|5|1H|7|1Q|A|30|6|3A|A|0|0|1E|P|6|W|A|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@$D|S|E|T|F|G]|$D|U|E|V|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|W|8|@$D|X|E|Y|F|J]|$D|Z|E|10|F|G]|$D|11|E|12|F|G]]|9|@]|A|$]]|$1|K|3|L|5|6|7|13|8|@$D|14|E|15|F|J]|$D|16|E|17|F|G]|$D|18|E|19|F|G]|$D|1A|E|1B|F|G]|$D|1C|E|1D|F|G]|$D|1E|E|1F|F|G]|$D|1G|E|1H|F|G]]|9|@]|A|$]]|$1|M|3|N|5|6|7|1I|8|@$D|1J|E|1K|F|J]|$D|1L|E|1M|F|G]|$D|1N|E|1O|F|G]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|1P|8|@]|9|@]|A|$]]]|P|$]]

@SebastianSimon my last answer is 8 years old (when I lamed) and it is possible I wrote some bull*hit :)
Briefly - currently the only cases when I am using <code>instanceof</code> is when I am using <code>class</code> instances and behaviour depends on class I will receive, eg. I want to distinct if 404 is ErrorA(resource not exists) or ErrorB(service not found) - library response codes were confusing but for my luck it throwed using different error classes.
Definitely (currently) I would NOT use it to check types that reflects primitives - you cannot be sure if library is returning <code>'msg'</code> or <code>new String('msg')</code>.
Both of them have methods that belongs to <code>String</code> class because <code>'msg'</code> primitive is internally wrapped into string object. Internally means by interpreter. They are both <code>Strings</code> but <code>instanceof</code> operator seems to be insufficient here - to check if sth. is primitive or class I would use mix of <code>typeof</code> &amp;&amp; <code>instanceof</code> - but only for something returned from external JS library.
Currenlty TypeScript is solving this problem and you no longer have to use such officious checks with <code>typeof</code> and <code>instanceof</code>.

The <code>instanceof</code> keyword in JavaScript can be quite confusing when it is first encountered, as people tend to think that JavaScript is not an object-oriented programming language.

<ul>
<li>What is it?</li>
<li>What problems does it solve?</li>
<li>When is it appropriate and when not?</li>
</ul>

What is the instanceof operator in JavaScript?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

当第一次遇到instanceof时，JavaScript中的JavaScript关键字可能会非常混乱，因为人们倾向于认为JavaScript不是面向对象的编程语言。那是什么？它解决了哪些问题？什么时候合适，什么时候不合适？

问在JavaScript中操作符的实例是什么？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在JavaScript中操作符的实例是什么？EN