实例

左侧 （LHS） 操作数是要测试到右侧 （RHS） 操作数的实际对象，该操作数是类的实际构造函数。基本定义是：

检查当前对象，如果对象属于指定的对象类型，则返回 true。

这里有一些很好的例子，这里有一个直接来自Mozilla开发者网站的例子：

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)

值得一提的一件事是，如果对象继承自类的原型，则计算为 true：instanceof

var p = new Person("Jon");
p instanceof Person

这是正确的，因为 继承自 。p instanceof PersonpPerson.prototype

根据OP的请求

声明变量时，请为其指定特定类型。

例如：

int i;
float f;
Customer c;

上面显示了一些变量，即 、 和 。这些类型是 和 用户定义的数据类型。诸如此类的类型可以用于任何语言，而不仅仅是JavaScript。但是，使用JavaScript，当您声明变量时，您没有显式定义类型，x可以是数字/字符串/用户定义的数据类型。因此，它的作用是检查对象以查看它是否属于指定的类型，因此从上面获取我们可以执行的对象：ifcintegerfloatCustomervar xinstanceofCustomer

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!

在上面，我们已经看到它是用类型声明的。我们对其进行了更新，并检查了它是否属于类型。当然，它返回 true。然后仍然使用对象，我们检查它是否是.不，绝对不是我们新推出的对象而不是对象。在这种情况下，它返回 false。cCustomerCustomerCustomerStringStringCustomerString

就是这么简单！

到目前为止，任何评论中似乎都没有涵盖实例的一个重要方面：继承。由于原型继承，通过使用 instanceof 进行计算的变量可能会对多个“类型”返回 true。

例如，让我们定义一个类型和一个子类型：

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;

现在我们有几个“类”，让我们创建一些实例，并找出它们的实例：

var 
    foo = new Foo()
,   subfoo = new SubFoo()
;

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

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

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

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

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

看到最后一行了吗？对函数的所有“new”调用都将返回一个从 Object 继承的对象。即使在使用对象创建速记时也是如此：

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

那么“类”定义本身呢？它们是什么实例？

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

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

我觉得理解任何对象都可以是多个类型的实例很重要，因为你（错误地）假设你可以通过使用来区分，比如说和object和函数。正如最后一个示例所示，函数是一个对象。instanceof

如果您正在使用任何继承模式，并希望通过鸭子类型以外的方法确认对象的后代，这一点也很重要。

希望能帮助任何人探索。instanceof