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

function isPlainObject(o) {
   return (o === null || Array.isArray(o) || typeof o == 'function' || o.constructor === Date ) ?
           false
          :(typeof o == 'object');
}

它生成下一个输出：

console.debug(isPlainObject(isPlainObject)); //function, false
console.debug(isPlainObject({'x': 6, 'y': 16})); //literal object, true
console.debug(isPlainObject(5)); //number, false
console.debug(isPlainObject(undefined)); //undefined, false
console.debug(isPlainObject(null)); //null, false
console.debug(isPlainObject('a')); //string, false
console.debug(isPlainObject([])); //array?, false
console.debug(isPlainObject(true)); //bool, false
console.debug(isPlainObject(false)); //bool, false

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

试试这个

if (objectName instanceof Object) {
  alert('Not an object');
}
else {
  alert('An object');
}

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

简短回答

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

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

案例1。

var anyVar = {};
typeof anyVar == 'object' && anyVar instanceof Object && !(anyVar instanceof Array) // true

案例2。

anyVar = [];
typeof anyVar == 'object' && anyVar instanceof Object && !(anyVar instanceof Array) // false

案例3。

anyVar = null;
typeof anyVar == 'object' && anyVar instanceof Object && !(anyVar instanceof Array); // false

解释

好吧，我们来分解一下

typeof anyVar==“object”从三个候选项中返回true-[]、｛｝和null，

anyVar instanceof Object将这些候选对象缩小到两个-[]，{}

!（anyVar instanceof Array）仅限于一个-{}

请滚鼓！

至此，您可能已经学会了如何在Javascript中检查Array。

lodash有isPlainObject，这可能是许多来到这个页面的人都在寻找的。当给定函数或数组时，它返回false。

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

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

什么是原始人？

3.“abc”真的无效的未定义

什么是对象（即不是基元）？

对象.原型Object.prototype派生的所有内容功能.原型对象作用函数C（）｛｝--用户定义函数C.prototype——用户定义函数的原型属性：这不是Cs原型new C（）--“new”-ing用户定义的函数数学阵列.原型阵列｛“a”：1，“b”：2｝--使用文字符号创建的对象new Number（3）--基元周围的包装器…许多其他事情。。。对象.create（null）从Object.create（null）派生的所有内容

如何检查值是否为对象

instanceof本身不起作用，因为它忽略了两种情况：

// oops:  isObject(Object.prototype) -> false
// oops:  isObject(Object.create(null)) -> false
function isObject(val) {
    return val instanceof Object; 
}

typeof x===“对象”无法工作，因为误报（null）和误报（函数）：

// oops: isObject(Object) -> false
function isObject(val) {
    return (typeof val === 'object');
}

Object.prototype.toString.call无法工作，因为所有基元都存在误报：

> Object.prototype.toString.call(3)
"[object Number]"

> Object.prototype.toString.call(new Number(3))
"[object Number]"

所以我使用：

function isObject(val) {
    if (val === null) { return false;}
    return ( (typeof val === 'function') || (typeof val === 'object') );
}

@Daan的回答似乎也奏效：

function isObject(obj) {
  return obj === Object(obj);
}

因为根据MDN文档：

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

第三种似乎有效的方法（不确定是否100%）是使用Object.getPrototypeOf，如果其参数不是对象，则抛出异常：

// these 5 examples throw exceptions
Object.getPrototypeOf(null)
Object.getPrototypeOf(undefined)
Object.getPrototypeOf(3)
Object.getPrototypeOf('abc')
Object.getPrototypeOf(true)

// these 5 examples don't throw exceptions
Object.getPrototypeOf(Object)
Object.getPrototypeOf(Object.prototype)
Object.getPrototypeOf(Object.create(null))
Object.getPrototypeOf([])
Object.getPrototypeOf({})

这是一个老问题，但我想把它留在这里。大多数人都在检查变量是否为｛｝，这意味着一个键值配对，而不是JavaScript用于给定对象的下划线构造，因为老实说，JavaScript中的大部分内容都是一个对象。所以把它从路上拿开。如果你这样做。。。

let x = function() {}
typeof x === 'function' //true
x === Object(x) // true
x = []
x === Object(x) // true

// also
x = null
typeof null // 'object'

大多数时候，我们想要的是知道我们是否有来自API的资源对象或从ORM返回的数据库调用。然后，我们可以测试是否不是数组、是否为null、是否为“function”类型、是否为Object

// To account also for new Date() as @toddmo pointed out

x instanceof Object && x.constructor === Object

x = 'test' // false
x = 3 // false
x = 45.6 // false
x = undefiend // false
x = 'undefiend' // false
x = null // false
x = function(){} // false
x = [1, 2] // false
x = new Date() // false
x = {} // true