检查一个值是否是JavaScript中的一个对象

你如何检查一个值是否是JavaScript中的对象?

尝试使用typeof(var)和/或var instanceof something

编辑:这个答案给出了如何检查variables的属性,但它不是一个防弹食谱(毕竟没有食谱!)检查是否是一个对象,远离它。 由于人们往往在没有做任何研究的情况下寻找要复制的东西,所以我强烈build议他们转向另一个,最上面的(而且是正确的)答案。

如果typeof yourVariable === 'object' ,它是一个对象或null。 如果你想排除null,只需使它yourVariable !== null && typeof yourVariable === 'object'你的yourVariable !== null && typeof yourVariable === 'object'

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

原始的,原始的价值

不是对象的数据,也没有任何方法。 JavaScript有5种基本数据types:string,数字,布尔值,空值,未定义。

什么是原始的?

  • 3
  • 'abc'
  • true
  • null
  • undefined

什么是对象(即不是原始的)?

  • Object.prototype
  • 所有东西都来自Object.prototype
    • Function.prototype
      • Object
      • Function
      • function C(){} – 用户定义的函数
    • C.prototype – 用户定义函数的原型属性:这不是 C的原型
      • new C() – “新” – 用户定义的函数
    • Math
    • Array.prototype
      • arrays
    • {"a": 1, "b": 2} – 使用文字符号创build的对象
    • new Number(3) – 原语的包装
    • 许多其他的事情
  • Object.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 === 'object'将不起作用,因为误报( 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') ); } 

大安的答案似乎也起作用:

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

因为根据MDN文档 :

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


似乎工作的第三种方法(不知道它是否是100%)是使用Object.getPrototypeOf ,如果它的参数不是一个对象,则引发exception :

 // 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({}) 

官方的underscore.js使用这个检查来找出是否真的是一个对象

 // Is a given variable an object? _.isObject = function(obj) { return obj === Object(obj); }; 

Object.prototype.toString.call(myVar)将返回:

  • "[object Object]"如果myVar是一个对象
  • "[object Array]"如果myVar是一个数组
  • 等等

有关这方面的更多信息,以及为什么它是typeof的一个很好的select, 请参阅这篇文章 。

我喜欢简单:

 function isObject (item) { return (typeof item === "object" && !Array.isArray(item) && item !== null); } 

如果该项目是一个JS对象,它不是一个JS数组,它不为null …如果三个都certificate是真的,则返回true 。 如果三个条件中的任何一个失败, &&testing将会短路并返回false 。 如果需要,可以省略nulltesting(取决于你如何使用null )。

DOCS:

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

只需检查对象或数组,而无需额外的函数调用(速度)。 也发布在这里 。

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 

isObject() – 注意:仅用于Object文字,因为它会为自定义对象返回false,如新的Date或new YourCustomObject。

 isObject = function(a) { return (!!a) && (a.constructor === Object); }; console.log(isObject( )); // false console.log(isObject( null)); // false console.log(isObject( true)); // false console.log(isObject( 1)); // false console.log(isObject( 'str')); // false console.log(isObject( [])); // false console.log(isObject(new Date)); // false console.log(isObject( {})); // true 

好的,让我们首先给你这个概念,然后回答你的问题,在JavaScript函数是对象,空,对象,数组和甚至date,所以你看它不是简单的方式像typeof obj ==='对象',所以提到的一切上面将返回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'; } 

要么

 //make sure the second object is capitalised function isObject(obj) { return Object.prototype.toString.call(obj) === '[object Object]'; } 

要么

 function isObject(obj) { return obj.constructor.toString().indexOf("Object") > -1; } 

要么

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

你可以通过调用它们在代码中简单地使用上面这些函数中的一个,如果它是一个对象,它将返回true:

 isObject(obj); 

如果你正在使用JavaScript框架,他们通常为你准备了这些function,这些function很less:

jQuery的:

  //It returns 'object' if real Object; jQuery.type(obj); 

angular度:

 angular.isObject(obj); 

下划线和Lodash:

 //(NOTE: in Underscore and Lodash, functions, arrays return true as well but not null) _.isObject(obj); 

这取决于你的意思是“是一个对象”。 如果你想要的东西不是一个原始的东西,即你可以设置新的属性的东西,这应该做的伎俩:

 function isAnyObject(value) { return value != null && (typeof value === 'object' || typeof value === 'function'); } 

它排除了原始数据(普通数字/ NaN / Infinity ,纯string, true / falseundefinednull ),但是对于其他所有数据(包括NumberBooleanString对象)都应该返回true。 请注意,JS没有定义什么“主机”对象,如windowconsole ,应该返回与typeof使用时,所以这些都很难用这样的检查来覆盖。

如果你想知道某个东西是否是一个“简单的”对象,也就是说,它是作为一个文字创build的,还是与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; } } 

检查一个值的types的最合理的方法似乎是typeof运算符。 唯一的问题是,它是可怕的破碎:

  • 它返回null "object" ,它属于空types。
  • 它为属于Objecttypes的可调用对象返回"function"
  • 它可以返回(几乎)任何它想要的非标准非可调用对象。 例如,IE似乎喜欢"unknown" 。 唯一禁止的结果是"function"和原始types。

typeof只对非null原语可靠。 所以一个检查一个值是否是对象的方法是确保typeof返回的string不对应于一个原语,并且该对象不是null 。 但是,问题是未来的标准可能会引入一个新的基本types,我们的代码会认为它是一个对象。 新types不经常出现,但是例如ECMAScript 6引入了符号types。

因此,我只推荐其结果取决于值是否是对象的方法,而不是typeof 。 以下打算成为一个

全面但并不完整的testing值是否属于对象types的正确方法列表。

  • Object构造函数

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

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

    下面的函数需要ECMAScript 3,它引入了===

     function isObject(value) { /* Requires ECMAScript 3 or later */ return Object(value) === value; } 

    我喜欢这种方法,因为它很简单,自我描述,类似的检查也适用于布尔值,数字和string。 但是,请注意,它依赖于全局Object不被遮挡或更改。

  • 构造函数

    当你实例化一个构造函数时,它可以返回一个不同于刚刚创build的实例的值。 但是这个价值将被忽略,除非它是一个对象。

    下面的函数需要ECMAScript 3,它允许构造函数返回非对象。 在ECMAScript 3之前抛出一个错误,但是try语句并不存在。

     function isObject(value) { /* Requires ECMAScript 3 or later */ return new function() { return value; }() === value; } 

    虽然比前面的例子简单一点,但是这个不依赖任何全局属性,因此可能是最安全的。

  • this

    旧的ECMAScript规范要求this值是一个对象。 ECMAScript 3引入了Function.prototype.call ,它允许用一个任意的this值调用一个函数,但是强制转换成一个对象。

    ECMAScript 5引入了一个严格的模式来消除这种行为,但是在马虎模式下,我们仍然可以(但可以说不应该)依赖它。

     function isObject(value) { /* Requires ECMAScript 3 or later in sloppy mode */ return function() { return this === value; }.call(value); } 
  • [[原型]]

    所有的普通对象都有一个名为[[Prototype]]的内部槽,它的值决定了从哪个其他对象inheritance而来。 该值只能是一个对象或null 。 因此,您可以尝试创build一个从所需值inheritance的对象,并检查它是否工作。

    Object.createObject.getPrototypeOf都需要ECMAScript 5。

     function isObject(value) { /* Requires ECMAScript 5 or later */ try { Object.create(value); return value !== null; } catch(err) { return false; } } 
     function isObject(value) { /* Requires ECMAScript 5 or later */ function Constructor() {} Constructor.prototype = value; return Object.getPrototypeOf(new Constructor()) === value; } 
  • 一些新的ECMAScript 6方法

    ECMAScript 6引入了一些新的间接方法来检查一个值是否是一个对象。 他们使用先前看到的方法将值传递给需要一个对象的代码,包装在一个try语句中以捕获错误。 一些隐藏的例子,不值得评论

     function isObject(value) { /* Requires ECMAScript 6 or later */ try { Object.setPrototypeOf({}, value); return value !== null; } catch(err) { return false; } } 

准备使用function进行检查

 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中, nullObjectArrayDatefunction都是对象。 虽然, null是有点人为的。 所以,最好首先检查null ,检测它不是null。

  • 检查typeof o === 'object'确保o是一个对象。 没有这个检查, Object.prototype.toString将是无意义的,因为它将返回对象的外挂,即使对于undefinednull ! 例如: toString(undefined)返回[object Undefined]

    typeof o === 'object'检查之后,toString.call(o)是一个很好的方法来检查o是否是一个对象,派生的对象如ArrayDate或者function

  • isDerivedObject函数中,它检查o是一个函数。 因为,function也是一个对象,这就是为什么它在那里。 如果不这样做,函数将返回false。 示例: isDerivedObject(function() {})将返回false ,但现在它返回true

  • 人们总是可以改变什么是对象的定义。 所以,可以相应地改变这些function。


testing

 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)); } // TESTS // is null an object? console.log( 'is null an object?', isObject(null) ); console.log( 'is null a derived object?', isDerivedObject(null) ); // is 1234 an object? console.log( 'is 1234 an object?', isObject(1234) ); console.log( 'is 1234 a derived object?', isDerivedObject(1234) ); // is new Number(1234) an object? console.log( 'is new Number(1234) an object?', isObject(new Number(1234)) ); console.log( 'is new Number(1234) a derived object?', isDerivedObject(1234) ); // is function object an object? console.log( 'is (new (function (){})) an object?', isObject((new (function (){}))) ); console.log( 'is (new (function (){})) a derived object?', isObject((new (function (){}))) ); // is {} an object? console.log( 'is {} an object?', isObject({}) ); console.log( 'is {} a derived object?', isDerivedObject({}) ); // is Array an object? console.log( 'is Array an object?', isObject([]) ) console.log( 'is Array a derived object?', isDerivedObject([]) ) // is Date an object? console.log( 'is Date an object?', isObject(new Date()) ); console.log( 'is Date a derived object?', isDerivedObject(new Date()) ); // is function an object? console.log( 'is function an object?', isObject(function(){}) ); console.log( 'is function a derived object?', isDerivedObject(function(){}) ); 

对于“简单的对象”(我的意思是,像{'x':5,'y':7}),我有这个小片段:

 function isPlainObject(o) { return ((o === null) || Array.isArray(o) || typeof o == 'function') ? 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”的types是“object”,而不是null或数组或函数时才返回“true”。 🙂

 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 

我被要求提供更多细节。 检查我们的variables是否是一个对象的最干净和可以理解的方式是typeof myVar 。 它返回一个types的string(例如"object""undefined" )。

不幸的是,Array和null也有一个typesobject 。 只接受真实对象需要使用instanceof运算符来检查inheritance链。 它将消除null,但Array具有inheritance链中的Object。

所以解决办法是:

 if (myVar instanceof Object && !(myVar instanceof Array)) { // code for objects } 

只是惊讶有多less错误的答案up
只有1个答案通过了我的testing! 在这里我创build了我的简化版本:

 function isObject(o) { return o instanceof Object && o.constructor === Object; } 

至于我,它很清楚,简单,只是工作! 在这里我的testing:

 console.log(isObject({})); // Will return: true console.log(isObject([])); // Will return: false console.log(isObject(null)); // Will return: false console.log(isObject(/.*/)); // Will return: false 

再一次:不是所有的答案都通过这个testing! 🙈

如果你需要validation对象是特定类的实例,你必须检查你的特定类的构造函数,如:

 function isDate(o) { return o instanceof Object && o.constructor === Date; } 

简单testing:

 var d = new Date(); console.log(isObject(d)); // Will return: false console.log(isDate(d)); // Will return: true 

因此,你将有严格和健壮的代码!

尝试这个

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

当一切都失败了,我用这个:

 var isObject = function(item) { return item.constructor.name === "Object"; }; 

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

  var isObject = function(obj) { var type = typeof obj; return type === 'function' || type === 'object' && !!obj; }; 

!!obj是检查对象是否真的简写(过滤掉null / undefined)

我认为这将工作。 返回true或false的函数,可能为null。

 const isObject = obj => obj && obj.constructor && obj.constructor === Object; isObject({}) // true isObject([]) // false isObject(new Number(123)) // false isObject(null) // null 

如果你已经使用AngularJS,那么它有一个内置的方法,将检查它的一个对象(不接受空)。

 angular.isObject(...) 

我喜欢使用的是这个

 function isObject (obj) { return typeof(obj) == "object" && !Array.isArray(obj) && obj != null && obj != "" && !(obj instanceof String) } 

我认为在大多数情况下,date必须通过支票作为对象,所以我不会过滤date

i found a "new" way to do just this kind of type checking from this SO question: Why does instanceof return false for some literals?

from that, i created a function for type checking as follows:

 function isVarTypeOf(_var, _type){ try { return _var.constructor === _type; } catch(ex) { return false; //fallback for null or undefined } } 

then you can just do:

 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 

this is tested on Chrome 56, Firefox 52, Microsoft Edge 38, Internet Explorer 11, Opera 43

编辑:
if you also want to check if a variable is null or undefined, you can use this instead:

 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 

update from inanc's comment: challenge accepted 😀

if you want to loose compare objects you can try this way:

 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 } } } 

that way, you can do just like inanc's comment:

 isVarTypeOf(new (function Foo(){}), Object); // returns false isVarTypeOf(new (function Foo(){}), Object, true); // returns true 

要么

 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 

use typeof(my_obj) will tells which type of variable it is.

if it is object will show 'object'

simple JS function,

 function isObj(v) { return typeof(v) == "object" } 

Eg:

 function isObj(v) { return typeof(v) == "object" } var samp_obj = { "a" : 1, "b" : 2, "c" : 3 } var num = 10; var txt = "Hello World!" var_collection = [samp_obj, num, txt] for (var i in var_collection) { if(isObj(var_collection[i])) { console.log("yes it is object") } else { console.log("No it is "+ typeof(var_collection[i])) } } 

Its depends on use-case, if we do not want to allow array and functions to be an Object, we can use the underscore.js builtin functions.

 function xyz (obj) { if (_.isObject(obj) && !_.isFunction(obj) && !.isArray(obj)) { // now its sure that obj is an object } } 
 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 

You can do this easily with toString() method of Object.prototype

 if(Object.prototype.toString.call(variable) == "[object Object]"){ doSomething(); } 

要么

 if(Object.prototype.toString.call(variable).slice(8,-1).toLowerCase() == "object"){ doSomething(); } 

A little NodeJS console experiment based on the reading of Matt Fenwick's third option to his complete answer above. Just a little tweak to get true or false .

The following return false for the object test.

 > 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 

The object will return true.

 > if(Object.getPrototypeOf({'this':10}) === Object.prototype){console.log(true);}else{console.log(false);} true undefined 

direct answer is ofcourse typeof v==='object' but this is terribly not useful. I wonder if the OP meant a plain dictionary ..

尝试:

 isdict(v) { return v !== undefined && v!==null && typeof v==='object' && v.constructor!==Array && v.constructor!==Date; } 

I have a code snippet that works. I find it confusing when the whole piece of code is not given, so I just created it myself:

  <!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>