如何检查值是否是JavaScript中的对象？
更新：
这个答案是不完整的，给出了误导性的结果。例如，null也被认为是JavaScript中的对象类型，更不用说其他几种边缘情况。遵循下面的建议，然后转到其他“最支持（和正确！）的答案”：
typeof yourVariable === 'object' && yourVariable !== null
原答覆：
尝试使用typeof（var）和/或var instanceof。
编辑：这个答案给出了如何检查变量财产的思路，但它并不是检查它是否是一个对象的万无一失的方法（毕竟根本没有方法。
如果typeof yourVariable==“object”，则它是一个对象或null。
如果要排除null、数组或函数，只需执行以下操作：
if (
typeof yourVariable === 'object' &&
!Array.isArray(yourVariable) &&
yourVariable !== null
) {
executeSomeCode();
}
试试这个
if (objectName instanceof Object) {
alert('Not an object');
}
else {
alert('An object');
}
Object.pr原型.toString.call（myVar）将返回：
“[object object]”如果myVar是对象“[object Array]”如果myVar是数组等
有关这方面的更多信息，以及为什么它是typeof的一个很好的替代品，请查看本文。
underscore.js提供了以下方法来确定某个对象是否真的是对象：
_.isObject = function(obj) {
return obj === Object(obj);
};
更新
由于V8之前的一个bug和轻微的微速度优化，自underscore.js 1.7.0（2014年8月）以来，该方法如下：
_.isObject = function(obj) {
var type = typeof obj;
return type === 'function' || type === 'object' && !!obj;
};
只需检查对象或数组，无需额外的函数调用（速度）。同样张贴在这里。
isArray（）
isArray = function(a) {
return (!!a) && (a.constructor === Array);
};
console.log(isArray( )); // false
console.log(isArray( null)); // false
console.log(isArray( true)); // false
console.log(isArray( 1)); // false
console.log(isArray( 'str')); // false
console.log(isArray( {})); // false
console.log(isArray(new Date)); // false
console.log(isArray( [])); // true
isLiteralObject（）-注意：仅用于Object文本，因为它对自定义对象（如newDate或newYourCustomObject）返回false。
isLiteralObject = function(a) {
return (!!a) && (a.constructor === Object);
};
console.log(isLiteralObject( )); // false
console.log(isLiteralObject( null)); // false
console.log(isLiteralObject( true)); // false
console.log(isLiteralObject( 1)); // false
console.log(isLiteralObject( 'str')); // false
console.log(isLiteralObject( [])); // false
console.log(isLiteralObject(new Date)); // false
console.log(isLiteralObject( {})); // true
我有一段代码片段可以使用。当没有给出整段代码时，我觉得很困惑，所以我自己创建了它：
<!DOCTYPE html>
<html>
<body>
<button onclick="myFunc()">Try it</button>
<script>
var abc = new Number();
// var abc = 4;
//this is a code variation which will give a diff alert
function myFunc()
{
if(abc && typeof abc === "object")
alert('abc is an object and does not return null value');
else
alert('abc is not an object');
}
</script>
</body>
</html>
让我们在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({})
我喜欢简单地：
function isObject (item) {
return (typeof item === "object" && !Array.isArray(item) && item !== null);
}
如果该项是一个JS对象，并且它不是一个JS数组，并且它不为空……如果这三个都是真的，则返回true。如果三个条件中的任何一个失败，&&测试将短路，并返回false。如果需要，可以省略null测试（取决于如何使用null）。
文档：
http://devdocs.io/javascript/operators/typeof
http://devdocs.io/javascript/global_objects/object
http://devdocs.io/javascript/global_objects/array/isarray
http://devdocs.io/javascript/global_objects/null
当其他一切都失败时，我使用这个：
var isObject = function(item) {
return item.constructor.name === "Object";
};
const isObject = function(obj) {
const type = typeof obj;
return type === 'function' || type === 'object' && !!obj;
};
!!obj是检查obj是否正确（以过滤空值）的简写
有点晚了。。。对于“普通对象”（我的意思是，像{'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”。:)
这取决于你所说的“是一个物体”。如果您想要所有非原语的内容，即可以设置新财产的内容，那么这应该可以做到：
function isAnyObject(value) {
return value != null && (typeof value === 'object' || typeof value === 'function');
}
它排除了基元（纯数字/NaN/Infinity、纯字符串、符号、true/false、undefined和null），但其他所有对象（包括Number、Boolean和String对象）都应返回true。注意，JS没有定义当与typeof一起使用时，应该返回哪些“主机”对象，例如窗口或控制台，因此很难用这样的检查来覆盖这些对象。
如果您想知道某个对象是“普通”对象，即它是作为文本｛｝创建的还是使用object.create（null）创建的，您可以这样做：
function isPlainObject(value) {
if (Object.prototype.toString.call(value) !== '[object Object]') {
return false;
} else {
var prototype = Object.getPrototypeOf(value);
return prototype === null || prototype === Object.prototype;
}
}
编辑2018：因为Symbol.toStringTag现在允许自定义Object.protoct.toString.call（…）的输出，所以上面的isPlainObject函数在某些情况下可能会返回false，即使对象以文本形式开始其生命。可以说，按照惯例，带有自定义字符串标记的对象不再是纯对象，但这进一步模糊了Javascript中的纯对象定义。
var isArray=function(value){
if(Array.isArray){
return Array.isArray(value);
}else{
return Object.prototype.toString.call(value)==='[object Array]';
}
}
var isObject=function(value){
return value !== null&&!isArray(value) && typeof value === 'object';
}
var _val=new Date;
console.log(isObject(_val));//true
console.log(Object.prototype.toString.call(_val)==='[object Object]');//false
var a = [1]
typeof a //"object"
a instanceof Object //true
a instanceof Array //true
var b ={a: 1}
b instanceof Object //true
b instanceof Array //false
var c = null
c instanceof Object //false
c instanceof Array //false
我被要求提供更多细节。检查变量是否为对象的最简单易懂的方法是myVar类型。它返回一个带有类型的字符串（例如“object”、“undefined”）。
不幸的是，Array和null都有一个类型对象。要仅获取真实对象，需要使用instanceof运算符检查继承链。它将消除null，但Array在继承链中有Object。
因此，解决方案是：
if (myVar instanceof Object && !(myVar instanceof Array)) {
// code for objects
}
您可以使用Object.prototype的toString（）方法轻松完成此操作
if(Object.prototype.toString.call(variable) == "[object Object]"){
doSomething();
}
or
if(Object.prototype.toString.call(variable).slice(8,-1).toLowerCase() == "object"){
doSomething();
}
检查值类型的最合理方法似乎是typeof运算符。唯一的问题是它已经严重损坏：
它为null返回“object”，这属于null类型。它为属于Object类型的可调用对象返回“函数”。对于非标准的不可调用对象，它可以返回（几乎）它想要的任何内容。例如，IE似乎喜欢“未知”。唯一被禁止的结果是“函数”和原始类型。
typeof仅对非空基元可靠。因此，检查值是否为对象的一种方法是确保typeof返回的字符串与原语不对应，并且对象不为空。然而，问题是未来的标准可能会引入一种新的原始类型，我们的代码会将其视为一个对象。新类型并不经常出现，但例如ECMAScript 6引入了Symbol类型。
因此，我只推荐结果随值是否为对象而变化的方法，而不是typeof。以下是
测试值是否属于Object类型的正确方法的全面但不详尽的列表。
对象构造函数Object构造函数将传递的参数强制为对象。如果它已经是一个对象，则返回相同的对象。因此，您可以使用它将值强制转换为对象，并将该对象与原始值严格比较。以下函数需要ECMAScript 3，它引入了==：函数isObject（value）｛/*需要ECMAScript 3或更高版本*/return Object（value）==value；}我喜欢这种方法，因为它简单且自我描述，类似的检查也适用于布尔值、数字和字符串。但是，请注意，它依赖于全局对象，而不是隐藏或更改。施工人员实例化构造函数时，它可以返回一个不同于刚刚创建的实例的值。但该值将被忽略，除非它是一个对象。以下函数需要ECMAScript 3，它允许构造函数返回非对象。在抛出错误的ECMAScript 3之前，try语句当时不存在。函数isObject（value）｛/*需要ECMAScript 3或更高版本*/return new函数（）｛return value；｝（）==value；}虽然比上一个例子简单一点，但这个例子不依赖任何全局属性，因此可能是最安全的。此值旧的ECMAScript规范要求此值为对象。ECMAScript 3引入了Function.prototype.call，它允许调用具有任意此值的函数，但强制为对象。ECMAScript 5引入了一个严格模式，删除了这种行为，但在草率模式下，我们仍然可以（但可以说不应该）依赖它。函数isObject（value）｛/*需要ECMAScript 3或更高版本处于草率模式*/return函数（）{return this==value；}.call（value）；}[[原型]]所有普通对象都有一个名为[[Prototype]]的内部槽，其值决定它从哪个其他对象继承。该值只能是对象或null。因此，您可以尝试创建继承自所需值的对象，并检查其是否有效。Object.create和Object.getPrototypeOf都需要ECMAScript 5。函数isObject（value）｛/*需要ECMAScript 5或更高版本*/尝试{对象.create（value）；返回值！==无效的}捕获（错误）{return false；}}函数isObject（value）｛/*需要ECMAScript 5或更高版本*/函数构造函数（）｛｝Constructor.prototype=值；return Object.getPrototypeOf（new Constructor（））==值；}一些新的ECMAScript 6方式ECMAScript 6引入了一些新的间接方法来检查值是否为对象。他们使用前面看到的方法将值传递给一些需要对象的代码，该对象封装在try语句中以捕获错误。一些隐藏的例子，不值得评论函数isObject（value）｛/*需要ECMAScript 6或更高版本*/尝试{Object.setPrototypeOf（｛｝，值）；返回值！==无效的}捕获（错误）{return false；}}函数isObject（value）｛/*需要ECMAScript 6或更高版本*/尝试{新的WeakSet（[value]）；返回true；}捕获（错误）{return false；}}
注意：我有意跳过了一些方法，例如Object.getPrototypeOf（value）（ES5）和Reflect方法（ES6），因为它们调用了可能会做坏事的基本内部方法，例如，如果value是代理。出于安全原因，我的示例仅引用值，而不直接访问它。
一个基于Matt Fenwick对其完整答案的第三个选项的NodeJS控制台实验。只要稍微调整一下就能判断真假。
以下对象测试返回false。
> if(Object.getPrototypeOf('v') === Object.prototype){console.log(true);}else{console.log(false);}
false
undefined
> if(Object.getPrototypeOf(1) === Object.prototype){console.log(true);}else{console.log(false);}
false
undefined
> if(Object.getPrototypeOf(false) === Object.prototype){console.log(true);}else{console.log(false);}
false
undefined
> if(Object.getPrototypeOf(['apple']) === Object.prototype){console.log(true);}else{console.log(false);}
false
undefined
对象将返回true。
> if(Object.getPrototypeOf({'this':10}) === Object.prototype){console.log(true);}else{console.log(false);}
true
undefined
可随时使用的检查功能
function isObject(o) {
return null != o &&
typeof o === 'object' &&
Object.prototype.toString.call(o) === '[object Object]';
}
function isDerivedObject(o) {
return !isObject(o) &&
null != o &&
(typeof o === 'object' || typeof o === 'function') &&
/^\[object /.test(Object.prototype.toString.call(o));
}
// Loose equality operator (==) is intentionally used to check
// for undefined too
// Also note that, even null is an object, within isDerivedObject
// function we skip that and always return false for null
解释
在Javascript中，null、Object、Array、Date和函数都是对象。虽然，null有点做作。因此，最好先检查空值，以检测它是否为空。检查o==“object”的类型可确保o是一个对象。如果不进行此检查，Object.prototype.toString将毫无意义，因为它将返回任何对象，即使是未定义和null！例如：toString（undefined）返回[object undefined]！在typeofo=='object'检查之后，toString.call（o）是一个很好的方法来检查o是一个对象，还是一个派生对象，如Array、Date或函数。在isDerivedObject函数中，它检查o是否为函数。因为，函数也是一个对象，这就是它存在的原因。若并没有这样做，函数将返回false。示例：isDerivedObject（function（）｛｝）将返回false，但现在返回true。人们总是可以改变对象的定义。因此，可以相应地更改这些函数。
测验
函数isObject（o）{返回null！=o&&typeof o==“对象”&&Object.pr原型.toString.call（o）==“[对象对象]”；}函数isDerivedObject（o）{回来isObject（o）&&空！=o&&（类型o==“对象”| |类型o===“函数”）&&/^\[object/.test（object.protype.toString.call（o））；}//测试//null是对象吗？控制台日志('是空的对象吗？'，isObject（空）);控制台日志('是否为null派生对象？'，isDerivedObject（空）);//1234是一个对象吗？控制台日志('1234是对象吗？'，isObject（1234）);控制台日志('1234是派生对象吗？'，isDerivedObject（1234）);//新编号（1234）是对象吗？控制台日志('新编号（1234）是对象吗？'，isObject（新编号（1234））);控制台日志('新编号（1234）是派生对象吗？'，isDerivedObject（1234）);//函数对象是对象吗？控制台日志('是（new（function（）｛｝））对象吗？'，isObject（（new（函数（）｛｝））);控制台日志(“（new（function（）｛｝））是派生对象吗？”，isObject（（new（函数（）｛｝））);//｛｝是对象吗？控制台日志(“是｛｝对象吗？”，isObject（｛｝）);控制台日志(“｛｝是派生对象吗？”，isDerivedObject（｛｝）);//Array是对象吗？控制台日志('数组是对象吗？'，isObject（[]）)控制台日志('数组是派生对象吗？'，isDerivedObject（[]）)//Date是对象吗？控制台日志('日期是对象吗？'，isObject（新日期（））);控制台日志('日期是派生对象吗？'，isDerivedObject（新日期（））);//函数是对象吗？控制台日志('函数是对象吗？'，isObject（函数（）｛｝）);控制台日志('函数是派生对象吗？'，isDerivedObject（函数（）｛｝）);
好的，在回答问题之前，让我们先给你这个概念，在JavaScript中，函数是Object，也可以是null、Object、Array甚至Date，所以正如你所看到的，没有一种简单的方法像typeof obj==“Object”，所以上面提到的一切都会返回true，但是有一些方法可以通过编写函数或使用JavaScript框架来检查它，好的：
现在，假设您有一个真正的对象（不是null、函数或数组）：
var obj = {obj1: 'obj1', obj2: 'obj2'};
纯JavaScript：
//that's how it gets checked in angular framework
function isObject(obj) {
return obj !== null && typeof obj === 'object';
}
or
//make sure the second object is capitalised
function isObject(obj) {
return Object.prototype.toString.call(obj) === '[object Object]';
}
or
function isObject(obj) {
return obj.constructor.toString().indexOf("Object") > -1;
}
or
function isObject(obj) {
return obj instanceof Object;
}
您可以简单地在代码中使用上述函数之一，方法是调用它们，如果它是一个对象，则返回true：
isObject(obj);
如果您使用的是JavaScript框架，他们通常会为您准备这些类型的函数，其中很少：
jQuery：
//It returns 'object' if real Object;
jQuery.type(obj);
角度：
angular.isObject(obj);
Undercore和Lodash：
//(NOTE: in Underscore and Lodash, functions, arrays return true as well but not null)
_.isObject(obj);
这会奏效的。它是一个返回true、false或可能为null的函数。
const isObject=obj=>obj&&obj.constructor&&obj.structor==对象；console.log（isObject（｛｝））；//真的console.log（isObject（[]））；//假的console.log（isObject（新函数））；//假的console.log（isObject（新编号（123）））；//假的console.log（isObject（null））；//无效的
我从这个SO问题中找到了一种“新”方法来进行这种类型检查：为什么instanceof对某些文本返回false？
在此基础上，我创建了一个类型检查函数，如下所示：
function isVarTypeOf(_var, _type){
try {
return _var.constructor === _type;
} catch(ex) {
return false; //fallback for null or undefined
}
}
那么你可以这样做：
console.log(isVarTypeOf('asdf', String)); // returns true
console.log(isVarTypeOf(new String('asdf'), String)); // returns true
console.log(isVarTypeOf(123, String)); // returns false
console.log(isVarTypeOf(123, Number)); // returns true
console.log(isVarTypeOf(new Date(), String)); // returns false
console.log(isVarTypeOf(new Date(), Number)); // returns false
console.log(isVarTypeOf(new Date(), Date)); // returns true
console.log(isVarTypeOf([], Object)); // returns false
console.log(isVarTypeOf([], Array)); // returns true
console.log(isVarTypeOf({}, Object)); // returns true
console.log(isVarTypeOf({}, Array)); // returns false
console.log(isVarTypeOf(null, Object)); // returns false
console.log(isVarTypeOf(undefined, Object)); // returns false
console.log(isVarTypeOf(false, Boolean)); // returns true
这在Chrome 56、Firefox 52、Microsoft Edge 38、Internet Explorer 11和Opera 43上进行了测试
编辑：如果您还想检查变量是否为空或未定义，则可以使用以下方法：
function isVarTypeOf(_var, _type){
try {
return _var.constructor === _type;
} catch(ex) {
return _var == _type; //null and undefined are considered the same
// or you can use === if you want to differentiate them
}
}
var a = undefined, b = null;
console.log(isVarTypeOf(a, undefined)) // returns true
console.log(isVarTypeOf(b, undefined)) // returns true
console.log(isVarTypeOf(a, null)) // returns true
财务评论更新：接受挑战：D
如果要松散比较对象，可以尝试以下方法：
function isVarTypeOf(_var, _type, looseCompare){
if (!looseCompare){
try {
return _var.constructor === _type;
} catch(ex){
return _var == _type;
}
} else {
try{
switch(_var.constructor){
case Number:
case Function:
case Boolean:
case Symbol:
case Date:
case String:
case RegExp:
// add all standard objects you want to differentiate here
return _var.constructor === _type;
case Error:
case EvalError:
case RangeError:
case ReferenceError:
case SyntaxError:
case TypeError:
case URIError:
// all errors are considered the same when compared to generic Error
return (_type === Error ? Error : _var.constructor) === _type;
case Array:
case Int8Array:
case Uint8Array:
case Uint8ClampedArray:
case Int16Array:
case Uint16Array:
case Int32Array:
case Uint32Array:
case Float32Array:
case Float64Array:
// all types of array are considered the same when compared to generic Array
return (_type === Array ? Array : _var.constructor) === _type;
case Object:
default:
// the remaining are considered as custom class/object, so treat it as object when compared to generic Object
return (_type === Object ? Object : _var.constructor) === _type;
}
} catch(ex){
return _var == _type; //null and undefined are considered the same
// or you can use === if you want to differentiate them
}
}
}
这样，你就可以像finance的评论一样：
isVarTypeOf(new (function Foo(){}), Object); // returns false
isVarTypeOf(new (function Foo(){}), Object, true); // returns true
or
Foo = function(){};
Bar = function(){};
isVarTypeOf(new Foo(), Object); // returns false
isVarTypeOf(new Foo(), Object, true); // returns true
isVarTypeOf(new Bar(), Foo, true); // returns false
isVarTypeOf(new Bar(), Bar, true); // returns true
isVarTypeOf(new Bar(), Bar); // returns true
我喜欢用这个
function isObject (obj) {
return typeof(obj) == "object"
&& !Array.isArray(obj)
&& obj != null
&& obj != ""
&& !(obj instanceof String) }
我认为在大多数情况下，Date必须作为Object通过检查，因此我不会过滤掉日期
usetypeof（myobj）将告诉它是哪种类型的变量。
对于阵列：Array.isArray（inp）或[]是数组的实例
如果是object，将显示“object”
简单的JS函数，
function isObj(v) {
return typeof(v) == "object"
}
Eg:
函数isObj（v）{return typeof（v）==“对象”}变量samp_obj={“a”：1，“b”：2，“c”：3}变量num=10；var txt=“您好！”var_collection=[samp_obj，num，txt]for（var_collection中的var i）{if（isObj（var_collection[i]））{console.log（“是的，它是对象”）}其他{console.log（“No it is”+typeof（var_collection[i]））}}
这取决于用例，如果我们不想让数组和函数成为Object，我们可以使用undercore.js内置函数。
function xyz (obj) {
if (_.isObject(obj) && !_.isFunction(obj) && !_.isArray(obj)) {
// now its sure that obj is an object
}
}
if(typeof value === 'object' && value.constructor === Object)
{
console.log("This is an object");
}
Ramda函数库具有检测JavaScript类型的出色功能。
完整功能的释义：
function type(val) {
return val === null ? 'Null' :
val === undefined ? 'Undefined' :
Object.prototype.toString.call(val).slice(8, -1);
}
当我意识到解决方案是多么简单和美丽时，我不得不笑了。
Ramda文档中的用法示例：
R.type({}); //=> "Object"
R.type(1); //=> "Number"
R.type(false); //=> "Boolean"
R.type('s'); //=> "String"
R.type(null); //=> "Null"
R.type([]); //=> "Array"
R.type(/[A-z]/); //=> "RegExp"
R.type(() => {}); //=> "Function"
R.type(undefined); //=> "Undefined"
如果您想检查对象的原型是否仅来自object。过滤掉字符串、数字、数组、参数等。
function isObject (n) {
return Object.prototype.toString.call(n) === '[object Object]';
}
或作为单个表达式箭头函数（ES6+）
const isObject = n => Object.prototype.toString.call(n) === '[object Object]'
大多数类型的obj[index]=='object'被使用，但它也会返回作为对象的函数和#document。这取决于你是否需要将其包括在结果中。
基本上，您可以通过检查控制台中的输出来过滤特定元素是否为对象的测试代码。在这里，您可以仅为示例运行代码：
函数cekObject（obj，index）｛if（！obj.tagName）{//测试用例#1if（对象类型==“对象”）{console.log（'obj['+index+']被列为对象'）；} }}<script src=“https://ajax.googleapis.com/ajax/libs/jquery/1.2.3/jquery.min.js“></script><脚本>函数updateFilters（）{var对象=$（'.j-image'）；$（'.juicer feed'）.empty（）；for（对象中的var索引）{cekObject（对象[index]，索引）；}; }</script><ul class=“榨汁机饲料”数据饲料id=“chetabahana”数据after=“updateFilters（）”></ul><script src=“https://assets.juicer.io/embed.js“></script>
您可以使用JSON.stringify来测试Object，如下所示：
var测试=｛｝if（JSON.stringify（测试）[0]==“｛”）{console.log（'这是一个对象'）}
考虑-typeof bar==“object”以确定bar是否为对象
虽然typeof bar==“object”是检查bar是否为对象的可靠方法，但JavaScript中令人惊讶的是，null也被视为对象！
因此，令大多数开发人员惊讶的是，以下代码将在控制台中记录true（而不是false）：
var bar=空；console.log（类型栏==“对象”）；//日志为真！只要意识到这一点，也可以通过检查bar是否为空来轻松避免该问题：
console.log（（bar！==null）&&（typeof bar==“object”））；//日志错误为了彻底回答，还有两件事值得注意：
首先，如果bar是一个函数，上述解决方案将返回false。在大多数情况下，这是所需的行为，但在希望函数也返回true的情况下，可以将上述解决方案修改为：
console.log（（bar！==null）&&（（bar类型==“对象”）||（bar类型===“函数”））；其次，如果bar是一个数组（例如，如果varbar=[]；），上述解决方案将返回true。在大多数情况下，这是所需的行为，因为数组确实是对象，但在您希望数组也为false的情况下，可以将上述解决方案修改为：
console.log（（bar！==null）&&（typeof bar==“object”）&&“[对象数组]”）；然而，还有另一种方法可以为null、数组和函数返回false，但为对象返回true：
console.log（（bar！==null）&&（bar.constructor==Object））；或者，如果您正在使用jQuery：
console.log（（bar！==null）&&（typeof bar==“object”）&&；
ES5使数组情况非常简单，包括它自己的空检查：
console.log（Array.isArray（bar））；
哦，我的上帝！我认为这可能比以往任何时候都要短，让我们看看：
短代码和最终代码
函数isObject（obj）{返回obj！=null&&obj.constructor.name==“对象”}console.log（isObject（｛｝））//返回trueconsole.log（isObject（[]））//返回falseconsole.log（isObject（null））//返回false
解释
退货类型
typeof JavaScript对象（包括null）返回“object”
console.log（类型为null，类型为[]，类型为｛｝）
检查其构造函数
检查其构造函数属性会返回带有其名称的函数。
console.log（（｛｝）.cconstructor）//返回名为“Object”的函数console.log（（[]）.cconstructor）//返回名为“Array”的函数console.log（（null）.cconstructor）//引发错误，因为null实际上没有属性
Function.name简介
Function.name返回函数的只读名称或闭包的“匿名”。
console.log（（｛｝）.cconstructor.name）//返回“Object”console.log（（[]）.cconstructor.name）//返回“Array”console.log（（null）.cconstructor.name）//引发错误，因为null实际上没有属性
注意：截至2018年，Function.name可能无法在IE中工作https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name#Browser_compatibility
我的上帝，其他答案太混乱了。
简短回答
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。
由于对于如何正确处理这个问题似乎有很多困惑，我将留下我的2美分（这个答案符合规范，在任何情况下都会产生正确的结果）：
测试原语：未定义的空布尔字符串数
function isPrimitive(o){return typeof o!=='object'||null}
对象不是基本体：
function isObject(o){return !isPrimitive(o)}
或者：
function isObject(o){return o instanceof Object}
function isPrimitive(o){return !isObject(o)}
测试任何阵列：
const isArray=(function(){
const arrayTypes=Object.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;
return function(o){
if (!o) return false;
return !isPrimitive(o)&&!!arrayTypes[o.constructor.name];
}
}());
测试对象排除：日期RegExp布尔数字字符串函数任意数组
const isObjectStrict=(function(){
const nativeTypes=Object.create(null);
nativeTypes['Date']=true;
nativeTypes['RegExp']=true;
nativeTypes['Boolean']=true;
nativeTypes['Number']=true;
nativeTypes['String']=true;
nativeTypes['Function']=true;
return function(o){
if (!o) return false;
return !isPrimitive(o)&&!isArray(o)&&!nativeTypes[o.constructor.name];
}
}());
如果明确希望检查给定值是否为｛｝。
function isObject (value) {
return value && typeof value === 'object' && value.constructor === Object;
}
在阅读并尝试了许多实现之后，我注意到很少有人尝试检查JSON、Math、文档或原型链长度超过1步的对象等值。
我认为，与其检查变量的类型，然后删除边缘事例，不如尽可能简单地进行检查，以避免在添加了注册为“对象”类型的新原语或本地对象时进行重构。
毕竟，typeof运算符会告诉您某个对象是否是JavaScript的对象，但JavaScript对对象的定义对于大多数真实场景来说太宽泛了（例如typeof null==“object”）。下面是一个函数，它通过基本上重复两次检查来确定变量v是否为对象：
只要v的字符串化版本为“[object object]”，就会启动一个循环。我希望函数的结果与下面的日志完全相同，所以这是我最终得出的唯一“对象性”标准。如果失败，函数将立即返回false。v被链中的下一个原型替换为v=Object.getPrototypeOf（v），但也在之后直接求值。当v的新值为null时，这意味着包括根原型（很可能是链中唯一的原型）在内的每个原型都通过了while循环中的检查，我们可以返回true。否则，新的迭代开始。
函数isObj（v）{while（Object.product.toString.call（v）=='[Object Object]'）if（（v=Object.getPrototypeOf（v））==null）返回truereturn false}console.log（'FALSE：'）console.log（'[]->'，isObj（[]））console.log（'ull->'，isObj（null））console.log（'文档->'，isObj（文档））console.log（'JSON->'，isObj（JSON））console.log（'function->'，isObj（函数（）｛｝））console.log（'newDate（）->'，isObj（newDate（（）））console.log（'RegExp->'，isObj（/./））console.log（'TRUE:'）console.log（“｛｝->”，isObj（｛｝））console.log（'newObject（）->'，isObj（newObject（（）））console.log（'新对象（null）->'，isObj（新对象（空）））console.log（'newObject（｛｝）->'，isObj（newObject（{foo:'bar'｝）））console.log（'Object.prototype->'，isObj（Object.prototype））console.log（'Object.create（null）->'，isObj（Object.create（null）））console.log（“Object.create（｛｝）->”，isObj（Object.create（｛foo:'bar'｝）））console.log（“deep继承->”，isObj（Object.create（Object.create（｛foo:'bar'｝））））
这是一个老问题，但我想把它留在这里。大多数人都在检查变量是否为｛｝，这意味着一个键值配对，而不是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
function isObjectLike(value) {
return value != null && typeof value == 'object' && !Array.isArray(value);
}
基于lodash
这是一个可选链接的答案，也许是这个问题的最小isObj函数。
常量isObj=o=>o？。构造函数==对象；//这是真的console.log（isObj（｛｝））；//对象//这些都是假的console.log（isObj（0））；//数字console.log（isObj（[]））；//大堆console.log（isObj（'ol'））；//一串console.log（isObj（null））；//无效的console.log（isObj（未定义））；//未定义console.log（isObj（（）=>｛｝））；//作用console.log（isObj（对象））；//班
出于代码的目的，我找到了与上面的一些答案相对应的决定：
ES6变体：
const checkType = o => Object.prototype
.toString
.call(o)
.replace(/\[|object\s|\]/g, '')
.toLowerCase();
ES5变体：
function checkType(o){
return Object.prototype
.toString
.call(o)
.replace(/\[|object\s|\]/g, '')
.toLowerCase();
}
您可以非常简单地使用它：
checkType([]) === 'array'; // true
checkType({}) === 'object'; // true
checkType(1) === 'number'; // true
checkType('') === 'string'; // true
checkType({}.p) === 'undefined'; // true
checkType(null) === 'null'; // true
等等
表演
今天2020.09.26我在Chrome v85、Safari v13.1.2和Firefox v80上对MacOs HighSierra 10.13.6进行了测试，以确定所选的解决方案。
后果
解决方案C和H在所有情况下在所有浏览器上都是快速/最快的在所有情况下，解决方案D和G在所有浏览器上都是慢/最慢的
细节
我为解决方案执行3个测试用例A.BCDEFGH我JKLMNOPQRSTU五、
对于小对象-您可以在此处运行对于大型对象-您可以在此处运行没有对象-你可以在这里运行
下面的代码片段介绍了解决方案之间的差异。解决方案A-G为Matt Fenwick描述的选定案例提供了正确的答案
// https://stackoverflow.com/a/14706877/860099函数A（x）{return x===对象（x）；};// https://stackoverflow.com/a/42250981/860099函数B（x）{return _.isObject（x）；}// https://stackoverflow.com/a/34864175/860099函数C（x）{返回x！=null&&（typeof x===“对象”| | typeof x====“函数”）；}// https://stackoverflow.com/a/39187058/860099函数D（x）{return new函数（）｛return x；｝（）==x；}// https://stackoverflow.com/a/39187058/860099函数E（x）{return函数（）{return this==x；}.call（x）；}// https://stackoverflow.com/a/39187058/860099函数F（x）｛/*需要ECMAScript 5或更高版本*/尝试{对象.create（x）；返回x！==无效的}捕获（错误）{return false；}}// https://stackoverflow.com/a/39187058/860099函数G（x）｛/*需要ECMAScript 5或更高版本*/函数构造函数（）｛｝Constructor.prototype=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]==“｛”：false；}// https://stackoverflow.com/a/13356338/860099函数L（x）{return Object.pr原型.toString.call（x）==“[对象对象]”；};// https://stackoverflow.com/a/46663081/860099函数M（o，strict=true）{如果（o==null | | o==未定义）{return false；}const instanceOfObject=o instanceof Object；const typeOfObject=typeof o==“对象”；constconstructorUndefined=o.constructor===未定义；constconstructorObject=o.constructor==对象；const typeOfConstructorObject=typeof 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.pr原型.toString.call（x）！=='[object对象]'）{return false；}其他{var prototype=对象.getPrototypeOf（x）；返回原型==null | |原型==Object.prototype；}}// https://stackoverflow.com/a/57863169/860099函数P（x）{while（Object.product.toString.call（x）=='[Object Object]'）if（（x=Object.getPrototypeOf（x））==null）返回truereturn false}// https://stackoverflow.com/a/43289971/860099函数Q（x）{尝试{开关（x.constructor）{案例编号：case函数：大小写布尔值：case符号：案例日期：case字符串：大小写RegExp：return x.constructor==对象；case错误：case评估错误：大小写范围错误：案例引用错误：case语法错误：案例类型错误：大小写URI错误：return（对象==错误？错误：x.constructor）==对象；case数组：大小写Int8Array：大小写Uint8Array：case Uint8ClampedArray：大小写Int16Array：大小写Uint16Array：case Int32Array：大小写Uint32Array：case Float32阵列：case浮点64Array：return（对象==数组？数组：x.constructor）==对象；case对象：违约：return（对象==对象？对象：x.constructor）==对象；}}捕获（ex）{return x==对象；}}// https://stackoverflow.com/a/52478680/860099函数R（x）{return typeof x=='对象'&&x对象实例&&！（数组的x实例）；}// https://stackoverflow.com/a/51458052/860099函数S（x）{返回x！=null&&x.constructor？。name==“对象”}// https://stackoverflow.com/a/42250981/860099函数T（x）{返回x？。构造函数？。toString（）.indexOf（“对象”）>-1；}// https://stackoverflow.com/a/43223661/860099函数U（x）{返回x？。构造函数==对象；}// https://stackoverflow.com/a/46663081/860099函数V（x）{返回x对象实例&&x.constructor==对象；}// -------------//测试// -------------console.log（'列：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=>console.log（`${f.name｝：${1*f（new Date（）））｝${1*f（/./）｝${1*f（｛｝）｝${1*f（Object.prototype）｝｛1*f（Object.create（null））｝$｛1*f（（）=>{}）｝-$｛1*f（“abc”）｝美元｛1*f（3）｝$1 1*（true）｝{1*（null）｝$2 1*f（未定义）｝`）））控制台日志(`列图例（测试用例）：1：新日期（）2: /./ （RegExp）3: {}4:对象.原型5:对象.create（null）6:（）=>｛｝（函数）7:“abc”（字符串）8:3（数字）9：真（布尔值）10:空11：未定义排：1=是对象0=不是对象理论上，第1-6列应有1，第7-11列应有0`);<脚本src=“https://code.jquery.com/jquery-3.5.1.min.js"integrity=“sha256-9/aliU8dGd2tb6OSsuzixeV4y/faTqgFtohetphpj0=”crossoorigin=“匿名”></script><脚本src=“https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.20/lodash.min.js" 完整性=“sha512-90vH1Z83AJY9DmlWa8WkjkV79yfS2n2Oxhsi2dZbIv0nC4E6m5AbH8Nh156kkM7JePmqD6tcZsfad1ueoaovww==”crossoorigin=“匿名”></script>此shippet只显示性能测试中使用的函数，而不执行测试本身！
下面是铬的示例结果
请记住，new Date（）的类型是“object”。
因此，如果要查找｛key:value｝对象，日期对象是无效的。
最后：o=>o&&typeof o==“对象”&&！在我看来，（o instance of Date）是对你问题的更好回答。
确定变量是否为Object的最简单方法：
第一个：评估对象的类型
第二个：从Object获取Array属性必须返回undefined（例如，长度是一个Array属性，它不适用于Object）
so:
if (_object instanceof Object && _object.length === undefined) {
// here you can be sure that you have a curly bracket object :)
}
这很棘手，因为数组是对象类型，函数是对象类型而实际对象｛｝也是对象类型
问题
const arr = []
const fun = function(){}
const actualObj = {}
arr instanceof Object // true
fun instanceof Object // true
actualObj instanceof Object // true
因此目标是actualObj必须返回true，其他所有值都必须返回false
actualObj instanceof Object && !(actualObj instanceof Array) && !(typeof actualObj === 'function') // true
简单的工作解决方案：
function isObject(value) {
return !(value instanceof Date) && !Array.isArray(value) && !Object.is(value, null) && !Object.is(value, undefined) && !(value instanceof Function)
}
我们可以只用一行来检查，这里obj可以是任何值（包括null）
obj?.__proto__ === Object.prototype
or
obj?.constructor.name === 'Object';
我认为有这么多答案的原因是，无论你是否喜欢，很多东西都是javascript中的对象。
您可以像任何其他对象一样迭代数组的“键”。。。
var key,
arr = ['one', 'two', 'three'];
for (key in arr)
console.log(`${key}=${arr[key]}`);
console.log(arr[1]);
console.log(arr['1']);
// 0=one
// 1=two
// 2=three
// two
// two
数组是特殊的（像许多对象一样），因为它有一些通用对象没有的财产/方法（例如长度、forEach等）。
所以这个问题应该是：如何过滤特定类型的对象？
毕竟，我可以很容易地实现自己的数组、正则表达式或符号，它也可以是一个对象，但可能会通过各种“它是真实对象吗？”测试。。。。因为它是一个真实的物体。
所以你想过滤到某些类型的javascript对象。。。
最好的方法是只做特性测试。例如，您是否关心它是否具有长度属性？示例：浏览器中的NodeList看起来像一个数组，可以像数组一样迭代，但不是数组。
无论如何，如果您只想过滤掉特定类型的对象，那么只有您才能定义要过滤的对象。是否要筛选出RegExp？日期大堆浏览器DOM对象？只有你才能决定你的过滤链是什么样子。您可以使用直通开关来构建紧凑的过滤器。
function typeOfIs(val, type) {
return typeof val == type;
}
function constructorIs(val, constructor) {
return val && constructor && val.constructor === constructor;
}
function isObject(val) {
// catch the easy non-object values
if (!typeOfIs(val, 'object'))
return false;
// catch the cases you don't want to consider to be
// "real" objects for your use-case
switch (true) {
case val === null:
case Array.isArray(val):
case typeOfIs(val, 'function'):
case constructorIs(val, RegExp):
return false;
default:
return true;
}
}
function test(val) {
console.log(Object.prototype.toString.call(val)+': '+isObject(val));
}
test(undefined);
test(null);
test(function () {});
test(Symbol('foo'));
test(1);
test(true);
test(false);
test('hello world');
test([]);
test(/.*/g);
test(new Date()); // true (because we didn't filter for it)
test({}); // true
特性测试
但更好的方法可能是询问为什么要筛选，或者只测试给定变量上是否存在您需要/期望的财产/函数。。。如果它们存在，使用变量，不要担心它是某种类型的对象还是另一种类型的对象。如果它们不存在，则抛出一个API错误，即您被传递了一些类型不正确的值（即缺少预期的财产/函数）。
e.g.
if (typeof someVariable.hasOwnProperty == 'function')
// ...
通过逆向选择的不同方法：
我回顾了这里的所有答案，但仍然缺少一种不同的方法。根据MDN文档，JavaScript中的对象是非原始值。基本值：
布尔型Null类型未定义的类型数字类型BigInt类型字符串类型符号类型
基于这一事实，以下方法正在实施逆向选择：
//根据MDN文档检查值是否为原始值：函数为PrimitiveValue（value）{返回(值类型==“符号”||类型值==“字符串”||值类型==“数字”||类型值==“boolean”||类型值==“未定义”||值==空||类型值==“bigint”);};//检查输入是否不是原始值，因此对象：函数isObject（输入）{if（isPrimitiveValue（输入））{return false；}返回true；};console.log（isObject（10））；//假的console.log（isObject（〔｛foo:“bar”｝〕））；//真的console.log（isObject（{a:1，b:2，c:3}））；//真的console.log（isObject（Object.getPrototypeOf（“foo”））；//真的console.log（isObject（符号（“foo”））；//假的console.log（isObject（BigInt（9007199254740991））；//假的console.log（isObject（null））；//假的console.log（isObject（未定义））；//假的console.log（isObject（false））；//假的console.log（isObject（｛｝））；//真的
适用于所有数据类型。它只显示对象
if (data && typeof data === 'object' && !Array.isArray(data)) {
isObject（）使用可选链接和最新标准检查传递的参数是否为对象：
const isObject = (value) => {
return value?.constructor === Object;
}
推荐文章
- 将.NET DateTime转换为JSON
- SameSite警告Chrome 77
- 在ES6 (ECMAScript 6)中是否有一种不带可变变量的循环x次的机制?
- 克隆对象没有引用javascript
- 验证字符串是否为正整数
- 如何获得一个键/值JavaScript对象的键
- 什么时候JavaScript是同步的?
- 如何在Typescript中解析JSON字符串
- Javascript reduce()在对象
- 在angularJS中& vs @和=的区别是什么
- 错误"Uncaught SyntaxError:意外的标记与JSON.parse"
- JavaScript中的querySelector和querySelectorAll vs getElementsByClassName和getElementById
- 给一个数字加上st, nd, rd和th(序数)后缀
- 如何以编程方式触发引导模式?
- setTimeout带引号和不带括号的区别
