我刚刚发现了一个真实的应用程序，我想现在会更经常地使用它。

如果你使用jQuery事件，有时你想写一个更通用的函数，也可以直接调用(没有事件)。您可以使用instanceof来检查函数的第一个参数是否是jQuery实例。事件并做出适当的反应。

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

在我的例子中，函数需要为所有(通过按钮上的单击事件)或仅为一个特定元素计算一些东西。我使用的代码:

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

我刚刚发现了一个真实的应用程序，我想现在会更经常地使用它。

如果你使用jQuery事件，有时你想写一个更通用的函数，也可以直接调用(没有事件)。您可以使用instanceof来检查函数的第一个参数是否是jQuery实例。事件并做出适当的反应。

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

在我的例子中，函数需要为所有(通过按钮上的单击事件)或仅为一个特定元素计算一些东西。我使用的代码:

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

instanceof只是isPrototypeOf的语法糖:

function Ctor() {}
var o = new Ctor();

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

o instanceof Ctor === Ctor.prototype.isPrototypeOf(o); // equivalent

Instanceof仅仅依赖于对象构造函数的原型。

构造函数只是一个普通的函数。严格来说，它是一个函数对象，因为在Javascript中所有东西都是对象。这个函数对象有一个原型，因为每个函数都有一个原型。

原型只是一个普通的对象，它位于另一个对象的原型链中。这意味着在另一个对象的原型链中使一个对象成为原型:

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

应该避免使用instanceof操作符，因为它伪造了Javascript中不存在的类。尽管class关键字在ES2015中也没有，因为class只是语法糖…但那是另一个故事了。

@SebastianSimon我最后的答案是8岁(那时我跛了)，有可能我写了一些牛逼的东西:)

简单地说——目前我使用instanceof的唯一情况是当我使用类实例时，行为取决于我将接收的类，例如。我想区分404是否为ErrorA(资源不存在)或ErrorB(服务未找到)-库响应代码令人困惑，但我的运气是使用不同的错误类抛出。

当然(目前)我不会用它来检查反映原语的类型——你不能确定库是否返回'msg'或new String('msg')。

它们都有属于String类的方法，因为'msg'原语在内部包装成字符串对象。内部是指通过解释器。它们都是字符串，但instanceof操作符似乎在这里是不够的-检查某事物是否是原始或类，我会使用typeof && instanceof的混合-但仅用于从外部JS库返回的东西。

目前TypeScript正在解决这个问题，你不再需要使用typeof和instanceof这样繁琐的检查。

我认为值得注意的是，instanceof是在声明对象时使用“new”关键字定义的。在JonH的例子中;

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

他没有提到的是;

var color1 = String("green");
color1 instanceof String; // returns false

指定"new"实际上是将String构造函数的结束状态复制到color1变量中，而不仅仅是将其设置为返回值。我认为这更好地展示了new关键字的功能;

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'

使用"new"将函数内的"this"值赋给已声明的var，而不使用它则赋给返回值。

这里的其他答案是正确的，但它们没有涉及instanceof的实际工作方式，这可能会引起一些语言律师的兴趣。

JavaScript中的每个对象都有一个原型，可以通过__proto__属性访问。函数也有一个prototype属性，它是由它们创建的任何对象的初始__proto__。当一个函数被创建时，它被赋予一个唯一的对象作为原型。instanceof操作符使用这种唯一性来给出答案。如果你把instanceof写成一个函数，它可能是这样的。

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__;
  }
}

这基本上是对ECMA-262 5.1版(也称为ES5)第15.3.5.3节的解释。

注意，可以将任何对象重新赋值给函数的prototype属性，也可以在构造对象后重新赋值对象的__proto__属性。这会给你一些有趣的结果:

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