blocks|key|676128|text|instanceof运算符指示第一个参数是否为给定类型。这就是说|type|unstyled|depth|inlineStyleRanges|entityRanges|data|676129|+A+instanceof+B|code-block|syntax|javascript|676130|如果A是类型B的实例，则返回true。|676131|另一方面，==和===运算符是比较运算符。他们比较相等的值。|676132|例如，你可以说jack+instanceof+boy是真的，但是你会说jack+==+Boy吗？不是的。|676133|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

instanceof operator indicates if the first argument is of the given type. That is saying 

<pre><code> A instanceof B
</code></pre>

returns true if A is an instance of the type B.

The == and === operators are comparison operators on the other hand. They compare values for equality.

For instance, you can say jack instanceof Boy is true but would you say that jack == boy? No.

blocks|key|676157|text|我认为这更多是由于定义对象的独特方式。你不是在javascript中定义类型，而是定义一个构造函数。但是您也没有将构造函数定义为构造函数，它只是一个函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|676158|然后，您可以通过它们的名称来引用这些类型，constructor....which只是一个函数。|676159|function+Tiger(){+//function,+or+object?
}

function+Apple(){+//function,+or+object?
}|code-block|syntax|javascript|676160|两者都可以是对象，也可能只是函数。只有你使用它们的方式才能决定这一点。因此，在较低的层次上，对象是函数，函数是对象，这是有意义的，但还是有区别的，对吧？|676161|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I think this is more due to the unique way in which objects are defined. You don't define a type in javascript, you define a constructor. But you also do not define the constructor as a constructor, it's simply a function.

You can then refer to the types by the name of their constructor....which is just a function.

<pre><code>function Tiger(){ //function, or object?
}

function Apple(){ //function, or object?
}
</code></pre>

Both could be objects, or perhaps just functions. Only the way you use them will determine that. So it kind of makes sense that at a low level, objects are functions and functions are objects, but there is still a difference, right?

blocks|key|676700|text|JavaScript中的一切都是Object，因为JavaScript是一种面向对象的语言。Function是Object的实例，因为一切都是Object的实例。很简单。但是，初始化其他对象(构造函数)的对象在JavaScript中也是Function，因此Object也是Function是有意义的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|676701|想想看：|676702|var+obj+=+new+Object();|code-block|syntax|javascript|676703|本例中的Object被用作Function，不是吗？因此，虽然从理论上讲，Object应该是语言中的最底层对象，但如果没有Functions+(双关语！)，JavaScript就不能工作，所以您需要将两者放在同一级别。Object需要是Function的一个实例，因为它是一个构造函数，它需要创建更多的自身实例。|676704|function+FooBar()+{}|676705|上面的FooBar类既是Object又是Function的实例，因为它两者都是。同样的逻辑也适用于内置的Object和Function对象；它们都是这两者的实例。|676706|呼，令人迷惑。这有什么意义吗？|676707|entityMap^0|G|6|1A|8|1J|6|1Z|6|3A|8|3L|6|3T|8|0|0|0|4|6|D|8|11|6|1P|8|31|6|3A|8|0|0|3|6|C|6|K|8|1G|6|1N|8|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]|$9|17|A|18|B|C]|$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1B|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1C|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1D|8|@$9|1E|A|1F|B|C]|$9|1G|A|1H|B|C]|$9|1I|A|1J|B|C]|$9|1K|A|1L|B|C]|$9|1M|A|1N|B|C]|$9|1O|A|1P|B|C]]|D|@]|E|$]]|$1|O|3|P|5|J|7|1Q|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1R|8|@$9|1S|A|1T|B|C]|$9|1U|A|1V|B|C]|$9|1W|A|1X|B|C]|$9|1Y|A|1Z|B|C]|$9|20|A|21|B|C]]|D|@]|E|$]]|$1|S|3|T|5|6|7|22|8|@]|D|@]|E|$]]|$1|U|3|-4|5|6|7|23|8|@]|D|@]|E|$]]]|V|$]]

Everything is an <code>Object</code> in JavaScript because JavaScript is an object-oriented language. <code>Function</code> is an instance of <code>Object</code> because everything is an instance of <code>Object</code>. Simple enough. However, objects that initialize other objects (constructors) are also <code>Function</code>s in JavaScript, so it would make sense for <code>Object</code> to also be a <code>Function</code>.

Think about this:

<pre><code>var obj = new Object();
</code></pre>

<code>Object</code> in this case is used as a <code>Function</code>, is it not? So while, in theory, <code>Object</code> should be the lowest-level object in the language, JavaScript cannot function without <code>Function</code>s (pun!), so you need both to be at the same level. <code>Object</code> needs to be an instance of <code>Function</code> because it's a constructor and it needs to create more instances of itself.

<pre><code>function FooBar() {}
</code></pre>

The <code>FooBar</code> class above is an instance of both <code>Object</code> and <code>Function</code>, because it's both. The same logic applies to the built-in <code>Object</code> and <code>Function</code> objects; they're instances of both.

Phew, confusing. Did that make any sense?

blocks|key|1977072|text|来自JavaScript+Prototypal+Inheritance|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1977073|在JavaScript中，|1977074|所有的东西都继承自Object。我们可以说Object是每个变量的超类，或者更好地说是超级构造器，一切都是一个instanceof对象。对象构造函数是一个函数，但函数是一个instanceof对象。这意味着这些断言总是正确的：|blockquote|1977075|1977076|(Object+instanceof+Function)+===+(Function+instanceof+Object)|style|CODE|1977077|上面的例子是正确的，因为Object是一个构造函数，而JavaScript中的构造函数总是一个函数。同时，每个函数都有自己的原型，原型总是从Object.prototype继承而来。函数构造函数本身就是一个函数，函数原型是一个function(){}；|1977078|(Function.prototype+instanceof+Object)+===+(function(){}+instanceof+Object)|1977079|entityMap|0|LINK|mutability|MUTABLE|url|http://www.3site.eu/doc/#Object|1|http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Operators:Special_Operators:instanceof_Operator|2|3|http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Operators:Comparison_Operators^0|2|X|0|0|0|0|0|0|7|8|A|J|16|8|A|1|0|0|0|J|K|A|V|7|13|3|17|W|K|A|2|13|3|3|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@$A|15|B|16|1|17]]|C|$]]|$1|D|3|E|5|6|7|18|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|19|8|@]|9|@]|C|$]]|$1|I|3|-4|5|6|7|1A|8|@]|9|@]|C|$]]|$1|J|3|K|5|6|7|1B|8|@$A|1C|B|1D|L|M]|$A|1E|B|1F|L|M]|$A|1G|B|1H|L|M]]|9|@$A|1I|B|1J|1|1K]]|C|$]]|$1|N|3|O|5|6|7|1L|8|@]|9|@]|C|$]]|$1|P|3|Q|5|6|7|1M|8|@$A|1N|B|1O|L|M]|$A|1P|B|1Q|L|M]|$A|1R|B|1S|L|M]|$A|1T|B|1U|L|M]|$A|1V|B|1W|L|M]]|9|@$A|1X|B|1Y|1|1Z]|$A|20|B|21|1|22]]|C|$]]|$1|R|3|-4|5|6|7|23|8|@]|9|@]|C|$]]]|S|$T|$5|U|V|W|C|$X|Y]]|Z|$5|U|V|W|C|$X|10]]|11|$5|U|V|W|C|$X|10]]|12|$5|U|V|W|C|$X|13]]]]

From <a href="http://www.3site.eu/doc/#Object" rel="nofollow noreferrer">JavaScript Prototypal Inheritance</a>:

<blockquote>
 Quite everything, in JavaScript, inherits from Object. We could say
 that Object is the super class, or better, the super constructor, of
 every variable and that everything is an instanceof Object. The Object
 constructor is a Function, but a Function is an instanceof Object.
 This means that these assertions are always true:
 
 <code>(Object <a href="http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Operators:Special_Operators:instanceof_Operator" rel="nofollow noreferrer">instanceof</a> Function) === (Function instanceof Object)</code>
 
 Above example is true because Object is a constructor, and a constructor in JavaScript is always a Function. At the same
 time, every Function has its own prototype, and a prototype always
 starts its inheritance from Object.prototype. The Function
 constructor, is a Function itself, and the function prototype is a
 function(){};
 
 <code>(Function.prototype <a href="http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Operators:Special_Operators:instanceof_Operator" rel="nofollow noreferrer">instanceof</a> Object) <a href="http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Operators:Comparison_Operators" rel="nofollow noreferrer">===</a> (function(){} instanceof Object)</code>
</blockquote>

blocks|key|820602|text|+javascript:alert([+window.navigator.userAgent,+Object+].join("\n\n")+)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|820603|显示|unstyled|820604|Mozilla/5.0+(X11;+U;+Linux+i686;+en-US;+rv:1.9.2.3)+Gecko/20100423+
++++Ubuntu/10.04+(lucid)+Firefox/3.6.3

function+Object()+{
++++[native+code]
}|820605|参考：Is+every+JavaScript+Object+a+function?|offset|length|820606|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/7018023/is-every-javascript-object-a-function^0|0|0|0|3|12|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|V|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$B|C]]|$1|I|3|J|5|F|7|X|8|@]|9|@$K|Y|L|Z|1|10]]|A|$]]|$1|M|3|-4|5|F|7|11|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

<pre><code> javascript:alert([ window.navigator.userAgent, Object ].join("\n\n") )
</code></pre>

displays

<pre><code>Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.2.3) Gecko/20100423 
 Ubuntu/10.04 (lucid) Firefox/3.6.3

function Object() {
 [native code]
}
</code></pre>

reference: <a href="https://stackoverflow.com/questions/7018023/is-every-javascript-object-a-function">Is every JavaScript Object a function?</a>

blocks|key|820656|text|Javascript中没有类这样的东西。在函数上调用instanceof运算符。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|820657|Object是“对象对象”的构造函数(是的，这是官方术语)，而Function是“函数对象”的构造函数。|820658|因此，当您调用Function+instanceof+Object时，它会返回true，因为Function是一个函数，因此是一个对象，等等。这并不意味着类型是相同的，因为对象和函数具有不同的原型：|820659|Object.prototype
+++%5E
+++%7C+inherits+from
+++%7C++++++++++++++++instance
Function.prototype++<-------++Object,+Function|code-block|syntax|javascript|820660|entityMap^0|Q|A|0|0|6|V|8|0|7|Q|13|4|1A|8|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|T|8|@$9|U|A|V|B|C]|$9|W|A|X|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|J|3|K|5|L|7|15|8|@]|D|@]|E|$M|N]]|$1|O|3|-4|5|6|7|16|8|@]|D|@]|E|$]]]|P|$]]

There is no such thing as classes in Javascript. The <code>instanceof</code> operator is called on functions.

<code>Object</code> is a constructor function for "Object objects" (yes, this is the official term), and <code>Function</code> is the constructor function for "Function objects".

So, when you call <code>Function instanceof Object</code>, it returns <code>true</code> because <code>Function</code> is a function, and thus an object, etc. This does not mean that the types are the same, because Object and Function have different prototypes:

<pre><code>Object.prototype
 ^
 | inherits from
 | instance
Function.prototype &lt;------- Object, Function
</code></pre>

blocks|key|820689|text|假设|type|unstyled|depth|inlineStyleRanges|entityRanges|data|820690|<-：链接到(通过+.__proto__**)**|offset|length|style|BOLD|CODE|820691|<--：继承了的属性(通过+.**)**|820692|然后|820693|对象函数<-{，Function.prototype}|820694|对象<-+Function.prototype|820695|Object.prototype+<--+Object|820696|console.log(Object.prototype.constructor+===+Object);+//+true!|code-block|syntax|javascript|820697|Object.prototype没有到任何东西的链接；它没有__proto__属性。|820698|entityMap^0|0|0|9|A|C|A|A|0|0|D|E|3|E|1|0|0|7|K|0|0|N|0|0|R|0|0|0|G|U|9|I|6|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|12|8|@$D|13|E|14|F|G]|$D|15|E|16|F|G]|$D|17|E|18|F|H]]|9|@]|A|$]]|$1|I|3|J|5|6|7|19|8|@$D|1A|E|1B|F|G]|$D|1C|E|1D|F|G]|$D|1E|E|1F|F|H]]|9|@]|A|$]]|$1|K|3|L|5|6|7|1G|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|1H|8|@$D|1I|E|1J|F|G]]|9|@]|A|$]]|$1|O|3|P|5|6|7|1K|8|@$D|1L|E|1M|F|G]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1N|8|@$D|1O|E|1P|F|G]]|9|@]|A|$]]|$1|S|3|T|5|U|7|1Q|8|@]|9|@]|A|$V|W]]|$1|X|3|Y|5|6|7|1R|8|@$D|1S|E|1T|F|H]|$D|1U|E|1V|F|H]|$D|1W|E|1X|F|G]]|9|@]|A|$]]|$1|Z|3|-4|5|6|7|1Y|8|@]|9|@]|A|$]]]|10|$]]

Suppose:

&lt;---- : links to (via <code>.__proto__</code>)

&lt;-- : has inherited property of (via <code>.</code>)

Then:

Function.prototype &lt;---- {Object, Function}

Object &lt;---- Function.prototype

Object.prototype &lt;-- Object

<pre><code>console.log(Object.prototype.constructor === Object); // true!
</code></pre>

<code>Object.prototype</code> does not link to anything; it doesn't have <code>__proto__</code> property.

<pre><code>Object instanceof Object
true
Object instanceof Function
true
Function instanceof Object
true
Function instanceof Function
true
</code></pre>

so if Function is an Object and the Object is a Function how come

<code>Function === Object</code> and <code>Function == Object</code> are false?

I do understand that checking the instance of an object is not the same as comparison. So the question here is the fuzziness in the case where if two objects (which are actually types) are instances of each other, shouldn't the types be the same?

Note: Object is not an instance of a Number or an Array just an instance of Function.

Object and Function are quite confusing

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

Object instanceof ObjecttrueObject instanceof FunctiontrueFunction instanceof ObjecttrueFunction instanceof Functiontrue那么，如果函数是一个对象，而对象又是一个函数，那么Function === Ob...

问对象和函数非常混乱
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问对象和函数非常混乱EN