检查值是否是JavaScript中的对象

Question

如何检查值是否是JavaScript中的对象？

Answer 1

如果typeof x===“对象”,x个是对象（函数除外）或无效的。如果你愿意无效的、数组和要排除的函数，只需使其：

typeof x===“对象”&&！数组.isArray（x）&&x！==无效的

Answer 2

更新:

这个答案是不完整的，会产生误导性的结果例如，无效的也被视为类型对象在JavaScript中，更不用说其他一些边缘情况了。遵循以下建议并继续“投票最多（而且正确！）的答案”:

yourVariable的类型===“对象”&&yourVaiable！==无效的

---

原答覆:

尝试使用类型（var）和/或某物的var实例.

编辑：这个答案给出了如何检查变量属性的思路，但它是不一个防弹配方（毕竟根本没有配方！），用于检查它是否是一个物体，离它很远。由于人们倾向于从这里寻找要复制的东西，而不做任何研究，我强烈建议他们转向另一个投票最多（而且正确！）的答案。

Answer 3

让我们在Javascript中定义“对象”.根据MDN文档，每个值都是对象或基本体：

基元，基元值

不是对象且没有任何方法的数据。JavaScript有7种基本数据类型：string、number、bigint、boolean、undefined、symbol和null。

什么是原语？

• 三
• “abc”
• 真的
• 无效的
• 未定义

什么是对象（即非基本体）？

• 对象.原型
• 一切都是从对象.原型
  • 函数.原型
    • 对象
    • 功能
    • 函数C（）{}--用户定义函数
  • C.原型--用户定义函数的原型属性：这是不 C类s原型
    • 新C（）--“新建”-使用用户定义的函数
  • 数学
  • 阵列原型
    • 阵列
  • {“a”：1，“b”：2}--使用文字符号创建的对象
  • 新编号（3）--基本体周围的包装
  • ...还有很多其他事情...
• Object.create（空）
• 一切都源于Object.create（null）

如何检查值是否为对象

运算符它本身不会起作用，因为它遗漏了两个案例：

//oops:isObject（Object.prototype）->false//oops:isObject（Object.create（null））->false函数isObject（val）{return val对象实例；}

typeof x===“对象”由于假阳性，无法工作(无效的)和假阴性（函数）：

//oops:isObject（Object）->false函数isObject（val）{return（类型val===“对象”）；}

对象.原型.to字符串.call不会起作用，因为所有原语都是误报：

>Object.prototype.toString.call（3）“[对象编号]”>Object.prototype.toString.call（新编号（3））“[对象编号]”

所以我使用：

函数isObject（val）{if（val===null）{return false；}return（（类型为val==='函数'）||（类型为val==='对象'））；}

---

@Daan的回答似乎也有效：

函数isObject（obj）{return obj===对象（obj）；}

因为，根据MDN文档:

Object构造函数为给定值创建对象包装器。如果值为null或未定义，它将创建并返回一个空对象，否则，它将返回一个与给定值对应的类型的对象。如果该值已经是一个对象，它将返回该值。

---

第三种似乎有效的方法（不确定是否为100%）是使用对象.get原型哪一个引发异常如果其参数不是对象：

//这5个示例抛出异常Object.getPrototypeOf（空）Object.getPrototypeOf（未定义）Object.getPrototypeOf（3）Object.getPrototypeOf（'abc'）Object.getPrototypeOf（true）//这5个示例没有抛出异常Object.getPrototypeOf（对象）Object.getPrototypeOf（Object.protype）Object.getPrototypeOf（Object.create（null））Object.getPrototypeOf（[]）Object.getPrototypeOf（{}）

Answer 4

下核.js提供了以下方法来确定某物是否真的是对象：

_.isObject=函数（obj）{return obj===对象（obj）；};

更新

由于V8之前的一个错误和微小的微速度优化，该方法看起来如下underscore.js 1.7.0（下核.js 1.7.0）（2014年8月）：

_.isObject=函数（obj）{var类型=对象类型；return type===“函数”||type==='对象'&&！！对象；};

Answer 5

Object.prototype.toString.call（myVar）将返回：

• “[对象对象]”如果myVar是对象
• “[对象数组]”如果myVar是数组
• 等。

有关这方面的更多信息，以及为什么它是typeof的好替代品，看看这篇文章.

Answer 6

用于简单检查对象或阵列无需额外的函数调用（速度）。同样发布了在这里.

isArray（）

isArray=函数（a）{return（！！a）&&（a.constructor===数组）；};console.log（isArray（））；//假console.log（isArray（null））；//假console.log（isArray（true））；//假console.log（isArray（1））；//假console.log（isArray（'str'））；//假console.log（isArray（{}））；//假console.log（isArray（new Date））；//假console.log（isArray（[]））；//真的

isLiteral对象（）-注：用于对象只返回文字假对于自定义对象，如新日期或新建YourCustomObject.

isLiteralObject=函数（a）{return（！！a）&&（a.constructor===对象）；};console.log（isLiteralObject（））；//假console.log（isLiteralObject（null））；//假console.log（isLiteralObject（true））；//假console.log（isLiteralObject（1））；//假console.log（isLiteralObject（'str'））；//假console.log（isLiteralObject（[]））；//假console.log（isLiteralObject（新日期））；//假console.log（isLiteralObject（{}））；//真的

Answer 7

我喜欢简单地说：

函数isObject（item）{return（typeof item===“object”&&！Array.isArray（item）&&item！==空）；}

如果该项是JS对象，并且不是JS数组，也不是无效的……如果这三个都证明是真的，请返回真的。如果三个条件中的任何一个失败&&测试将短路假将返回。这个无效的如果需要，可以省略测试（取决于您的使用方式无效的).

文件编号：

http://devdocs.io/javascript/operators/typeof

http://devdocs.io/javascript/global_objects/object

http://devdocs.io/javascript/global_objects/array/isaray

http://devdocs.io/javascript/global_objects/null

Answer 8

使用函数阵列.isArray:

函数isObject（o）{返回o！==null&&typeof o===“对象”&&Array.isArray（o）===false；}

无功能阵列.isArray:

只是奇怪有多少人支持错误的答案😮
仅限1个答案通过了我的测试！！！在这里，我创建了我的简化版本：

函数isObject（o）{return o对象实例&&o.constructor===对象；}

对我来说，它清晰而简单，而且很有效！这里是我的测试：

console.log（isObject（{}））；//将返回：trueconsole.log（isObject（[]））；//将返回：falseconsole.log（isObject（null））；//将返回：falseconsole.log（isObject（/.*/））；//将返回：falseconsole.log（isObject（函数（）{}））；//将返回：false

再一次：并非所有答案都通过了测试！！！🙈

---

如果您需要验证对象特定类的实例您必须使用特定类检查构造函数，如：

函数isDate（o）{return o instanceof Object&&o.constructor===日期；}

简单测试：

var d=新日期（）；console.log（isObject（d））；//将返回：falseconsole.log（isDate（d））；//将返回：true

因此，您将拥有严格而健壮的代码！

---

如果您不会创建以下功能isDate（是日期）,is错误,isRegExp公司等，您可以考虑使用此通用函数的选项：

函数isObject（o）{return o instanceof Object&&typeof o.constructor===“函数”；}

它不能正确地用于前面提到的所有测试用例，但对于所有对象（普通的或构造的）来说已经足够了。

---

is对象在发生以下情况时不起作用Object.create（空）因为内部实施对象创建这是解释在这里但你可以使用is对象在更复杂的实现中：

函数isObject（o，strict=true）{if（o===null||o===未定义）{返回false；}const instanceOfObject=o对象实例；const typeOfObject=类型o===“对象”；const constructorUndefined=o.constructor===未定义；const constructorObject=o.constructor===对象；const typeOfConstructorObject=o.constructor类型===“函数”；设r；if（严格===真）{r=（instanceOfObject||typeOfObject）&&（constructorUndefined||constructor对象）；}其他{r=（constructorUndefined||typeOfConstructorObject）；}返回r；};

已经创建了npm上的包v1基于此实现！它适用于所有先前描述的测试用例！🙂

Answer 9

哦，我的上帝！我认为这可能比以往更短，让我们看看：

短代码和最终代码

函数isObject（obj）{返回对象！=null&&obj.constructor.name===“对象”}console.log（isObject（{}））//返回trueconsole.log（isObject（[]））//返回falseconsole.log（isObject（null））//返回false

解释

退货类型

JavaScript对象的类型（包括无效的)收益“对象”

console.log（typeofnull，typeof[]，typeof{}）

检查他们的施工人员

检查他们的建造师属性返回函数及其名称。

console.log（（{}）.constructor）//返回名为“Object”的函数console.log（（[]）.constructor）//返回一个名为“Array”的函数console.log（（null）.constructor）//抛出错误，因为null实际上没有属性

函数名称简介

功能名称返回函数的只读名称或“匿名”用于闭合。

console.log（（{}）.constructor.name）//返回“Object”console.log（（[]）.constructor.name）//返回“Array”console.log（（null）.constructor.name）//抛出错误，因为null实际上没有属性

注： 截至2018年，Function.name可能无法在中使用工业工程

Answer 10

试试这个

if（objectName对象实例）{警报（“物体”）；}其他{alert（“非对象”）；}

Answer 11

好吧，在回答你的问题之前，让我们先给你这个概念，在JavaScript中，函数是Object，也有null、Object、Arrays甚至Date，所以你可以看到不像typeofobj===“object”这样的简单方法，所以上面提到的所有内容都将返回true，但可以通过编写函数或使用JavaScript框架进行检查，好的：

现在，假设您有一个真正的对象（不是null或函数或数组）：

变量obj={obj1:“obj1”，obj2:“obj 2”}；

纯JavaScript：

//这就是如何在角度框架中进行检查函数isObject（obj）{返回对象！==null&&typeof obj===“对象”；}

或

//确保第二个对象大写函数isObject（obj）{return Object.prototype.toString.call（obj）===“[对象对象]”；}

或

函数isObject（obj）{return obj.constructor.toString（）.indexOf（“Object”）>-1；}

或

函数isObject（obj）{return obj instanceof Object；}

您可以简单地在代码中使用上述函数之一，方法是调用它们，如果它是一个对象，它将返回true：

是对象（obj）；

如果您使用的是JavaScript框架，他们通常会为您准备这些功能，以下是其中的一些功能：

jQuery：

//如果是实object，则返回“object”；jQuery.type（obj）；

角度：

角度.is对象（obj）；

下划线和Lodash：

//（注意：在Undercore和Lodash中，函数和数组也返回true，但不返回null）_.is对象（obj）；

Answer 12

这取决于你所说的“是一个物体”是什么意思。如果你想要的不是原始的也就是说，您可以对其设置新属性，这应该可以做到：

函数isAnyObject（值）{返回值！=null&&（typeof value===“object”||typeof value===“function”）；}

它不包括原语（普通数字/NaN公司/无穷，普通字符串，符号，真的/假,未定义和无效的)但对于其他一切（包括编号,布尔值和字符串对象）。注意，JS没有定义什么“主机”对象，例如窗口或慰问，与一起使用时应返回类型，所以像这样的支票很难盖住这些。

如果你想知道某个东西是否是一个“普通”对象，即它是作为文字创建的{}或使用Object.create（空），您可以这样做：

函数isPlainObject（值）{if（Object.prototype.toString.call（value）！=='[object对象]'）{返回false；}其他{var prototype=Object.getPrototypeOf（值）；return prototype===null||prototype===Object.prototype；}}

2018年编辑：因为符号.to字符串标记现在允许自定义Object.prototype.toString.call（…），的isPlain对象上面的函数可能返回假在某些情况下，甚至当对象以文字形式开始其生命时。可以说，按照惯例，带有自定义字符串标记的对象不再是纯对象，但这进一步模糊了Javascript中纯对象的定义。

Answer 13

我的上帝，其他答案太混乱了。

简短回答

typeof anyVar==“object”&&anyVar对象实例&&！（数组的anyVar实例）

要测试这一点，只需在chrome控制台中运行以下语句。

案例1。

变量anyVar={}；typeof anyVar==“object”&&anyVar对象实例&&！（anyVar数组实例）//true

案例2。

任意变量=[]；typeof anyVar==“object”&&anyVar对象实例&&！（anyVar数组实例）//false

案例3。

anyVar=空；typeof anyVar==“object”&&anyVar对象实例&&！（数组的anyVar实例）；//假

解释

可以。让我们把它分解

typeof anyVar==“对象”三位候选人回答为“真”-[]、{}和null,

对象的anyVar实例把这些候选人缩小到两人-[], {}

!（数组的anyVar实例）缩小到只有一个-{}

请滚圆！

通过此操作，您可能已经学会了如何在Javascript中检查数组。

Answer 14

下面是可选链接的答案，可能是最小的是对象此问题的函数。

常量isObj=o=>o？。constructor===对象；//这是真的控制台.log（isObj（{}））；//反对！//这些错误console.log（isObj（0））；//数console.log（isObj（[]））；//阵列console.log（isObj（'lo'））；//一串console.log（isObj（null））；//无效的console.log（isObj（未定义））；//未定义控制台.log（isObj（（）=>{}））；//功能console.log（isObj（Object））；//班

Answer 15

检查值类型的最合理方法似乎是类型操作员。唯一的问题是它破得很厉害：

• 它会返回“对象”对于无效的，属于Null类型。
• 它会返回“功能”对于属于Object类型的可调用对象。
• 它可以为非标准的不可调用对象返回（几乎）它想要的任何内容。例如，IE似乎喜欢“未知”。唯一禁止的结果是“功能”和基元类型。

类型（共种）仅对非-无效的基本体。因此，检查值是否为对象的方法是确保类型与基元不对应，并且对象不是无效的然而，问题是未来的标准可能会引入新的基元类型，而我们的代码会将其视为对象。新类型并不经常出现，但例如ECMAScript 6引入了Symbol类型。

因此类型，我只推荐结果根据值是否为对象而变化的方法。以下内容旨在成为

测试值是否属于Object类型的正确方法的全面列表，但并不详尽。

• 对象建造师

  这个对象构造函数将传递的参数强制为对象。如果它已经是一个对象，则返回相同的对象。

  因此，可以使用它将值强制为对象，并将该对象与原始值进行严格比较。

  以下函数需要ECMAScript 3，它引入了===:

  函数isObject（value）{/*需要ECMAScript 3或更高版本*/return Object（value）===value；}

  我喜欢这种方法，因为它简单且自我描述，类似的检查也适用于布尔值、数字和字符串。然而，要知道它依赖于全球对象没有被遮蔽或改变。

• 建造师

  实例化构造函数时，它可以返回与刚创建的实例不同的值。但该值将被忽略，除非它是一个对象。

  以下函数需要ECMAScript 3，它允许构造函数返回非对象。在引发错误的ECMAScript 3之前，但是尝试当时还没有声明。

  函数isObject（value）{/*需要ECMAScript 3或更高版本*/return new function（）{return value；}（）===value；}

  虽然与前一个示例相比有点简单，但此示例不依赖任何全局属性，因此可能是最安全的。

• 这价值

  旧的ECMAScript规范要求这值作为对象。引入ECMAScript 3功能.原型.call，它允许使用任意这值，但强制为对象。

  ECMAScript 5引入了一个严格的模式来消除这种行为，但在草率模式下，我们仍然可以（但可以说不应该）依赖它。

  function isObject（value）{/*在slopy模式下需要ECMAScript 3或更高版本*/return function（）｛return this==value；｝.call（value）；}

• [[原型]]

  所有普通对象都有一个名为[[Prototype]]的内部插槽，其值决定了它从哪个其他对象继承。该值只能是对象或无效的。因此，您可以尝试创建从所需值继承的对象，并检查它是否有效。

  两者都有对象.创建和对象.get原型需要ECMAScript 5。

  函数isObject（value）{/*需要ECMAScript 5或更高版本*/尝试{Object.create（值）；返回值！==无效的；}捕获（错误）{返回false；}}

  函数isObject（value）{/*需要ECMAScript 5或更高版本*/函数构造函数（）{}Constructor.protype=值；return Object.getPrototypeOf（new Constructor（））===值；}

• 一些新的ECMAScript 6方式

  ECMAScript 6引入了一些新的间接方法来检查值是否为对象。它们使用前面看到的方法将值传递给一些需要对象的代码，这些对象包装在尝试语句捕获错误。一些隐藏的例子，不值得评论

  函数isObject（value）{/*需要ECMAScript 6或更高版本*/尝试{Object.setPrototypeOf（{}，值）；返回值！==无效的；}捕获（错误）{返回false；}}

  函数isObject（value）{/*需要ECMAScript 6或更高版本*/尝试{新的WeakSet（[值]）；返回true；}捕获（错误）{返回false；}}

---

注意：我故意跳过了一些方法，比如Object.getPrototypeOf（值）（ES5）和反射方法（ES6），因为它们称为可能会做出令人讨厌的事情的基本内部方法，例如，如果价值是代理。出于安全考虑，我的示例仅供参考价值没有直接访问它。

Answer 16

随时可用的检查功能

函数isObject（o）{返回null！=o和&类型o===“对象”&&Object.prototype.toString.call（o）===“[对象对象]”；}函数isDerivedObject（o）{返回！是对象（o）&&空！=o和&（typeof o===“对象”|| typeof o===“函数”）&&/^\[对象/.test（object.prototype.toString.call（o））；}//松散等式运算符（==）专门用于检查//对于未定义的//还要注意，即使null也是isDerivedObject中的一个对象//函数，我们跳过它并总是为null返回false

---

解释

• 在Javascript中，无效的,对象,阵列,日期和功能s都是对象。虽然，无效的有点做作。因此，最好检查无效的首先，检测它不为空。

• 正在检查typeof o===“对象”保证o（o）是一个对象。如果没有这张支票，对象.原型.to字符串这是毫无意义的，因为它会为任何事物返回对象，即使是未定义和无效的! 例如：toString（未定义）收益[对象未定义]!

  之后typeof o===“对象”check，toString.call（o）是检查o（o）是一个对象，类似于阵列,日期或功能.

• 在是派生对象函数，它检查o（o）是一个函数。因为函数也是一个对象，这就是它存在的原因。如果它没有这样做，函数将返回false。例子：是派生对象（函数（）{}）会回来的假但现在它又回来了真的.

• 人们总是可以改变对象的定义。因此，可以相应地更改这些函数。

---

测验

函数isObject（o）{返回null！=o&&类型o===“对象”&&Object.prototype.toString.call（o）===“[对象对象]”；}函数isDerivedObject（o）{返回！is对象（o）&&空！=o和&（typeof o===“对象”|| typeof o===“函数”）&&/^\[对象/.test（object.prototype.toString.call（o））；}//测试//null是一个对象吗？控制台.log('是否为null对象？'，isObject（空）);控制台.log(“null是派生对象吗？”，isDerivedObject（空）);//1234是一个对象吗？控制台.log('1234是对象吗？'，是对象（1234）);控制台日志('1234是派生对象吗？'，是派生对象（1234）);//新数字（1234）是对象吗？控制台.log('新编号（1234）是对象吗？'，isObject（新编号（1234））);控制台.log('新编号（1234）是派生对象吗？'，是派生对象（1234）);//函数对象是对象吗？控制台.log('（new（function（）{}））是对象吗？'，isObject（（新（函数（）{}））);控制台.log('（new（function（）{}））是派生对象吗？'，isObject（（new（function（）｛｝））);//{}是对象吗？控制台.log(“{}是对象吗？”，是对象（{}）);控制台日志(“{}是派生对象吗？”，是派生对象（{}）);//数组是对象吗？控制台.log('数组是对象吗？'，是对象（[]）)控制台.log(“Array是派生对象吗？”，是派生对象（[]）)//Date是对象吗？控制台.log('日期是对象吗？'，isObject（新日期（））);控制台.log(“Date是派生对象吗？”，isDerivedObject（new Date（））);//函数是一个对象吗？控制台.log('函数是对象吗？'，isObject（函数（）{}）);控制台.log('函数是派生对象吗？'，是派生对象（函数（）{}）);

Answer 17

有点晚了。。。对于“普通对象”（我的意思是，像{'x'：5，'y'：7}），我有一个小片段：

函数isPlainObject（o）{return（o===null||Array.isArray（o）||typeof o=='函数'||o.constructor===日期）？假：（类型o==“对象”）；}

它生成下一个输出：

console.debug（isPlainObject（isPlain Object））//函数，falseconsole.debug（isPlainObject（{'x'：6，'y'：16}））//文字对象，trueconsole.debug（isPlainObject（5））//数字，假console.debug（isPlainObject（未定义））//未定义，错误console.debug（isPlainObject（null））//空，假console.debug（isPlainObject（'a'））//字符串，falseconsole.debug（isPlainObject（[]））//数组？，假console.debug（isPlainObject（true））//布尔，假console.debug（isPlainObject（false））//布尔，假

它总是适用于我。只有当“o”的类型是“object”，而不是null、数组或函数时，If才会返回“true”。:)

Answer 18

如果您想检查原型对于对象完全来自对象.过滤掉字符串,编号,阵列,论据等。

函数isObject（n）{return Object.prototype.toString.call（n）===“[对象对象]”；}

或作为单表达式箭头函数（ES6+）

const isObject=n=>Object.prototype.toString.call（n）===“[对象对象]”

Answer 19

变量a=[1]//“对象”的类型Object的一个实例//true数组的一个实例//true变量b={a:1}b对象实例//trueb数组实例//falsevar c=空c对象实例//falsec数组实例//false

我被要求提供更多细节。检查变量是否为对象的最干净、最容易理解的方法是myVar的类型。它返回一个带有类型的字符串（例如。“对象”,“未定义”).

不幸的是，Array和null也有一个类型对象。要仅获取真实对象，需要使用检查继承链运算符操作员。它将消除null，但Array在继承链中有Object。

所以解决方案是：

if（myVar instanceof Object&&！（myVar-instanceof Array））{//对象代码}

Answer 20

洛达什有isPlain对象，这可能是许多来到本页的人所寻找的。当给定函数或数组时，它返回false。

Answer 21

这个兰达函数库有一个很好的检测JavaScript类型的功能。

解释全功能:

功能类型（val）{返回val===空？'空'：val===未定义？'“未定义”：Object.prototype.toString.call（val）.slice（8，-1）；}

当我意识到这个解决方案是多么简单和美丽时，我忍不住笑了。

Ramda的用法示例文档:

R.type（{}）；//=>“对象”R型（1）；//=>“数字”R.type（错误）；//=>“布尔型”R.type（s’）；//=>“字符串”R.type（空）；//=>“空”R型（[]）；//=>“数组”R型（/[A-z]/）；//=>“RegExp”R.type（（）=>{}）；//=>“功能”R.type（未定义）；//=>“未定义”

Answer 22

性能

今天2020.09.26，我在Chrome v85、Safari v13.1.2和Firefox v80上对MacO HighSierra 10.13.6进行了测试，以获得选定的解决方案。

结果

• 在所有情况下，解决方案C和H在所有浏览器上都是快速/最快的
• 在所有情况下，解决方案D和G在所有浏览器上都是最慢/最慢的

细节

我为解决方案执行了3个测试用例A类 B类 C类 D类 E类 F类 G公司 H（H） 我 J型 K（K） L（左） M（M） N个 O（运行） P（P） 问 R（右） S公司 T型 U型 V（V）

• 对于小对象-您可以运行它酒店雇员和饭馆雇员
• 对于大物体-你可以运行它酒店雇员和饭馆雇员
• 无对象-您可以运行它酒店雇员和饭馆雇员

下面的代码片段显示了解决方案之间的差异。解决方案A-G为以下描述的所选案例提供了适当的答案马特·芬威克

// https://stackoverflow.com/a/14706877/860099函数A（x）{return x===对象（x）；};// https://stackoverflow.com/a/42250981/860099函数B（x）{返回_.isObject（x）；}// https://stackoverflow.com/a/34864175/860099函数C（x）{返回x！=null&&（typeof x===‘object’||typeof x===‘function’）；}// https://stackoverflow.com/a/39187058/860099函数D（x）{return new function（）{return x；}（）===x；}// https://stackoverflow.com/a/39187058/860099函数E（x）{return function（）{return this===x；}.call（x）；}// https://stackoverflow.com/a/39187058/860099函数F（x）｛/*需要ECMAScript 5或更高版本*/尝试{Object.create（x）；返回x！==无效的；}捕获（错误）{返回false；}}// https://stackoverflow.com/a/39187058/860099函数G（x）{/*需要ECMAScript 5或更高版本*/函数构造函数（）{}构造函数原型=x；return Object.getPrototypeOf（new Constructor（））===x；}// https://stackoverflow.com/a/8511332/860099函数H（x）{返回类型x===“对象”&&x！==无效的}// https://stackoverflow.com/a/25715455/860099函数I（x）{return（typeof x===“object”&&！Array.isArray（x）&&x！==空）；};// https://stackoverflow.com/a/22482737/860099函数J（x）{return x instanceof Object；}// https://stackoverflow.com/a/50712057/860099函数K（x）{设t=JSON.stringify（x）；返回t？t[0]===“{”：假；}// https://stackoverflow.com/a/13356338/860099函数L（x）{return Object.prototype.toString.call（x）===“[对象对象]”；};// https://stackoverflow.com/a/46663081/860099函数M（o，strict=true）{if（o===null||o===未定义）{返回false；}const instanceOfObject=o对象实例；const typeOfObject=类型o===“对象”；const constructorUndefined=o.constructor===未定义；const constructorObject=o.constructor===对象；const typeOfConstructorObject=o.constructor类型===“函数”；设r；if（严格===真）{r=（instanceOfObject || typeOfObject）&&（constructorUndefined || constructorObject）；}其他{r=（constructorUndefined||typeOfConstructorObject）；}返回r；}// https://stackoverflow.com/a/42250981/860099函数N（x）{return$.type（x）===“对象”；}// https://stackoverflow.com/a/34864175/860099函数O（x）{if（Object.prototype.toString.call（x）！=='[对象对象]'）{返回false；}其他{var原型=Object.getPrototypeOf（x）；return prototype===null||prototype===Object.prototype；}}// https://stackoverflow.com/a/57863169/860099函数P（x）{while（Object.prototype.toString.call（x）===“[对象对象]”）if（（x=Object.getPrototypeOf（x））===null）返回true返回false}// https://stackoverflow.com/a/43289971/860099函数Q（x）{尝试{开关（x.constructor）{案例编号：case函数：case布尔值：外壳符号：案例日期：case字符串：案例RegExp：return x.constructor===对象；case错误：案例评估错误：案例范围错误：案例引用错误：case语法错误：案例类型错误：案例URI错误：return（Object===错误？错误：x.constructor）===对象；case数组：case Int8Array（大小写Int8Array）：case Uint8Array：case Uint8ClampedArray：案例Int16Array：案例Uint16Array：案例Int32Array：案例Uint32Array：案例Float32Array：案例Float64Array：return（Object===数组？数组：x.constructor）===对象；case对象：违约：return（Object===Object？Object:x.constructor）===对象；}}捕获（ex）{return x==对象；}}// https://stackoverflow.com/a/52478680/860099函数R（x）{return typeof x=='object'&&x instanceof object&&！（x个数组实例）；}// https://stackoverflow.com/a/51458052/860099函数S（x）{返回x！=null&&x.构造函数？。name===“对象”}// https://stackoverflow.com/a/42250981/860099函数T（x）{返回x？。构造函数？。toString（）.indexOf（“对象”）>-1；}// https://stackoverflow.com/a/43223661/860099函数U（x）{返回x？。constructor===对象；}// https://stackoverflow.com/a/46663081/860099函数V（x）{return x对象实例&&x.constructor===对象；}// -------------//测试// -------------控制台日志（'列：1 2 3 4 5 6-7 8 9 10 11'）；【A、B、C、D、E、F、G、H、I、J、K、L、M、N、O、P、Q、R、S、T、U、V】.map（f=>控制台.log（`${f.name}:${1*f（new Date（））}${1*.f（/./）}$}1*f内联）}`））控制台.log(`列图例（测试用例）：1：新日期（）2: /./ （注册费用）3: {}4：对象原型5:Object.create（空）6:（）=>｛｝（函数）7:“abc”（字符串）8:3（数字）9:true（布尔值）10:空11：未定义排：1=是对象0=不是对象理论上，第1-6列应该有1，第7-11列应该有0`);

<脚本src=“https://code.jquery.com/jquery-3.5.1.min.js"完整性=“sha256-9/aliU8dGd2tb6OSsuzixeV4y/faTqgFtohetphbj0=”crossource=“anonymous”></script><脚本src=“https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.20/lodash.min.js" 完整性=“sha512-90vH1Z83AJY9DmlWa8WkjkV79yfs2n2Oxhsi2dZbIv0nC4E6m5AbH8Nh156kkM7JePmqD6tcZsfad1ueoaovwww==”crossource=“anonymous”></script>这艘船只提供性能测试中使用的功能，它本身不执行测试！

下面是铬的示例结果

Answer 23

由于对于如何正确处理这个问题似乎有很多困惑，我将留下2美分（这个答案符合规范，在所有情况下都会产生正确的结果）：

原语测试：未定义 无效的 布尔值 一串 数

函数isPrimitive（o）{返回类型o！=='object'||null}

对象不是基本体：

函数isObject（o）｛return！isPrimitive（o）｝

或者：

函数isObject（o）{返回对象的o实例}函数isPrimitic（o）{return！isObject（o）}

测试任何阵列：

const isArray=（函数（）{const arrayTypes=对象.create（null）；arrayTypes['Array']=true；arrayTypes['Int8Array']=true；arrayTypes['Uint8Array']=true；arrayTypes['Uint8ClampedArray']=true；arrayTypes['Int16Array']=true；arrayTypes['Uint16Array']=true；arrayTypes['Int32Array']=true；arrayTypes['Uint32Array']=true；arrayTypes['BigInt64Array']=true；arrayTypes['BigUint64Array']=true；arrayTypes['Float32Array']=true；arrayTypes['Float64Array']=true；返回函数（o）{如果（！o）返回false；返回！是原语（o）&&！！arrayTypes[o.constructor.name]；}}());

对象测试，不包括：日期 注册Exp 布尔值 编号 字符串 功能任意数组

const isObjectStrict=（函数（）{const nativeTypes=Object.create（null）；nativeTypes['Date']=true；nativeTypes['RegExp']=true；nativeTypes['Boolean']=true；nativeTypes['Number']=true；nativeTypes['String']=true；nativeTypes['Function']=true；返回函数（o）{if（！o）返回false；返回！是原语（o）&&！isArray（o）&&！nativeTypes[o.constructor.name]；}}());

Answer 24

在阅读并尝试了许多实现之后，我注意到很少有人尝试检查以下值JSON格式,数学,文件或原型链长度超过1步的对象。

而不是检查类型我认为，如果检查尽可能简单，以避免在添加新的原语或本机对象时进行重构，那么最好将其注册为类型“object”的。

毕竟类型接线员会告诉你是JavaScript的对象，但JavaScript对对象的定义对于大多数实际场景来说过于宽泛（例如。typeof null===“对象”).下面是一个函数，用于确定变量五本质上是重复两次检查的对象：

1. 只要字符串化版本的五是“[对象对象]”.
   我希望函数的结果与下面的日志完全相同，所以这是我最后得出的唯一“对象性”标准。如果失败，函数将立即返回false。
2. 五替换为链中的下一个原型v=Object.getPrototypeOf（v），也可以在之后直接评估。当的新值五是无效的，这意味着每个原型，包括根原型（很可能是只有链内的原型）已经通过while循环中的检查，我们可以返回true。否则，将开始新的迭代。

函数isObj（v）{while（Object.prototype.toString.call（v）===“[对象对象]”）if（（v=Object.getPrototypeOf（v））===空）返回true返回false}console.log（'FALSE:'）控制台.log（'[]->'，isObj（[]））console.log（'null->'，isObj（null））console.log（'document->'，isObj（document））console.log（'JSON->'，isObj（JSON））console.log（'function->'，isObj（function（）{}））console.log（'new Date（）->'，isObj（new Date[）]）控制台.log（'RegExp->'，isObj（/./））console.log（'TRUE:'）控制台.log（'{}->'，isObj（{}））console.log（'new Object（）->'，isObj（new Objects（）））console.log（'新对象（null）->'，isObj（新对象（null）））log（'new Object（{}）->'，isObj（新对象（{foo:'bar'}））console.log（'对象原型->'，isObj（对象原型））console.log（“Object.create（null）->”，isObj（Object.create[null））console.log（“Object.create（{}）->”，isObj（Object.created（{foo:'bar'}））console.log（'deep heritance->'，isObj（Object.create（Object.create（｛foo:'bar'｝）））

Answer 25

就我的代码而言，我发现这个决定与上面的一些答案相对应：

ES6变型：

const checkType=o=>对象原型.to字符串.call（o）.replace（/\[|对象\s|\]/g，“”）.to下壳体（）；

ES5变体：

功能检查类型（o）{return对象原型.to字符串.调用（o）.replace（/\[|object\s|\]/g，''）.to下壳体（）；}

您可以非常简单地使用它：

checkType（[]）===“数组”；//真的checkType（{}）===“对象”；//真的checkType（1）===“数字”；//真的checkType（“”）===“字符串”；//真的checkType（{}.p）===“未定义”；//真的checkType（null）===“null”；//真的

等等。。

Answer 26

当其他一切都失败时，我使用这个：

var isObject=函数（项）{return item.constructor.name===“对象”；};

Answer 27

这将起作用。它是一个返回true、false或可能为null的函数。

const isObject=obj=>obj&&obj.constructor&&obj constructor==对象；console.log（isObject（{}））；//真的console.log（isObject（[]））；//假console.log（isObject（新函数））；//假console.log（isObject（新编号（123））；//假console.log（isObject（null））；//无效的

Answer 28

if（值类型===“对象”&&value.constructor===对象）{console.log（“这是一个对象”）；}

Answer 29

如果明确要检查给定值是否为{}.

函数isObject（值）{返回值&&typeof value===“对象”&&value.constructor===对象；}

Answer 30

const isObject=函数（obj）{常量类型=对象类型；return type===“函数”||type==='对象'&&！！目标；};

!!对象是检查是否对象是真实的（过滤掉无效的)