Verificar se um valor é um object em JavaScript

Como você verifica se um valor é um object em JavaScript?

Tente usar typeof(var) e / ou var instanceof something .

EDIT: Esta resposta dá uma idéia de como examinar as propriedades da variável, mas não é uma receita à prova de balas (afinal, não há receita!) Para verificar se é um object, longe disso. Como as pessoas tendem a procurar algo para copiar daqui sem fazer nenhuma pesquisa, eu recomendo que elas voltem para a outra, a mais votada (e correta!).

Se typeof yourVariable === 'object' , é um object ou nulo. Se você quiser excluir null, basta torná-lo yourVariable !== null && typeof yourVariable === 'object' .

Vamos definir “object” em Javascript . De acordo com os documentos do MDN , cada valor é um object ou um primitivo:

valor primitivo primitivo

Um dado que não é um object e não possui nenhum método. JavaScript tem 5 tipos de dados primitivos: string, number, boolean, null, undefined.

O que é um primitivo?

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

O que é um object (ou seja, não primitivo)?

  • Object.prototype
  • tudo desceu do Object.prototype
    • Function.prototype
      • Object
      • Function
      • function C(){} – funções definidas pelo usuário
    • C.prototype – a propriedade prototype de uma function definida pelo usuário: este não é o protótipo de C s
      • new C() – “novo” – uma function definida pelo usuário
    • Math
    • Array.prototype
      • matrizes
    • {"a": 1, "b": 2} – objects criados usando notação literal
    • new Number(3) – wrappers primitivos
    • muitas outras coisas
  • Object.create(null)
  • tudo descende de um Object.create(null)

Como verificar se um valor é um object

por si só não funcionará, porque falta dois casos:

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

typeof x === 'object' não funcionará, devido a falsos positivos ( null ) e falsos negativos (functions):

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

Object.prototype.toString.call não funcionará devido a falsos positivos para todas as primitivas:

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

Então eu uso:

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

Resposta @ Daan também parece funcionar:

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

porque, de acordo com os documentos do MDN :

O construtor Object cria um wrapper de object para o valor fornecido. Se o valor for nulo ou indefinido, ele criará e retornará um object vazio, caso contrário, retornará um object de um tipo que corresponde ao valor fornecido. Se o valor já for um object, ele retornará o valor.


Uma terceira maneira que parece funcionar (não tenho certeza se é 100%) é usar Object.getPrototypeOf que lança uma exceção se seu argumento não for um object:

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

O underscore.js oficial usa essa verificação para descobrir se algo é realmente um object

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

Object.prototype.toString.call(myVar) retornará:

  • "[object Object]" se myVar é um object
  • "[object Array]" se myVar é uma matriz
  • etc.

Para mais informações sobre isso e por que é uma boa alternativa ao typeof, confira este artigo .

Eu gosto de simplesmente:

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

Se o item é um object JS, e não é um array JS, e não é null … se todos os três forem verdadeiros, retorne true . Se qualquer uma das três condições falhar, o teste && será curto-circuitado e false será retornado. O teste null pode ser omitido, se desejado (dependendo de como você usa 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

Para simplesmente verificar contra Object ou Array sem chamada de function adicional (velocidade). Como também postado aqui .

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 () – Nota: use apenas para literais de object, pois ele retorna false para objects personalizados, como new Date ou 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 

Com a function Array.isArray :

 function isObject(o) { return o !== null && typeof o === 'object' && Array.isArray(o) === false; } 

Sem function Array.isArray :

Apenas surpreendeu quantas votações para respostas erradas 😮
Apenas 1 resposta passou nos meus testes !!! Aqui eu criei minha versão simplificada:

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

Quanto a mim, é claro e simples, e só funciona! Aqui meus testes:

 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 console.log(isObject(function () {})); // Will return: false 

Mais uma vez: nem todas as respostas passam nos testes !!! 🙈


Caso você precise verificar se o object é uma instância de determinada class, você deve verificar o construtor com sua class específica, como:

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

teste simples:

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

Como resultado, você terá um código estrito e robusto!


Caso você não crie funções como isDate , isError , isRegExp , etc, você pode considerar a opção de usar estas funções generalizadas:

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

ele não funcionará corretamente para todos os casos de teste mencionados anteriormente, mas é bom o suficiente para todos os objects (lisos ou construídos).


isObject não funcionará no caso de Object.create(null) por causa da implementação interna de Object.create que é explicada aqui, mas você pode usar isObject em uma implementação mais sofisticada:

 function isObject(o, strict = true) { if (o === null || o === undefined) { return false; } const instanceOfObject = o instanceof Object; const typeOfObject = typeof o === 'object'; const constructorUndefined = o.constructor === undefined; const constructorObject = o.constructor === Object; const typeOfConstructorObject = typeof o.constructor === 'function'; let r; if (strict === true) { r = (instanceOfObject || typeOfObject) && (constructorUndefined || constructorObject); } else { r = (constructorUndefined || typeOfConstructorObject); } return r; }; 

Já existe um pacote criado no npm v1 baseado nesta implementação! E funciona para todos os casos de teste descritos anteriormente! 🙂

OK, vamos dar-lhe este conceito antes de responder a sua pergunta, em JavaScript Funções são Object, também null, Object, Arrays e até Date, então como você vê não existe uma maneira simples como typeof obj === ‘object’, então tudo mencionado acima retornará true , mas existem maneiras de verificar isso com a criação de uma function ou usando estruturas JavaScript, OK:

Agora, imagine que você tenha esse object que é um object real (não nulo ou function ou array):

 var obj = {obj1: 'obj1', obj2: 'obj2'}; 

JavaScript puro:

 //that's how it gets checked in angular framework function isObject(obj) { return obj !== null && typeof obj === 'object'; } 

ou

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

ou

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

ou

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

Você pode simplesmente usar uma dessas funções como acima em seu código chamando-as e ela retornará true se for um object:

 isObject(obj); 

Se você estiver usando uma estrutura JavaScript, eles geralmente prepararam esse tipo de function para você, estes são alguns deles:

jQuery:

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

Angular:

 angular.isObject(obj); 

Underscore e Lodash:

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

Depende do que você quer dizer com “é um object”. Se você quer tudo o que não é primitivo , isto é, coisas nas quais você pode definir novas propriedades, isso deve funcionar:

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

Ele exclui as primitivas (números simples / NaN / Infinity , strings simples, true / false , undefined e null ), mas deve retornar true para todo o resto (incluindo objects Number , Boolean e String ). Observe que o JS não define quais objects “host”, como window ou console , devem retornar quando usados ​​com typeof , então é difícil cobrir esses dados com uma verificação como essa.

Se você quer saber se algo é um object “simples”, isto é, se foi criado como um literal {} ou com Object.create(null) , você pode fazer isto:

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

A maneira mais razoável de verificar o tipo de um valor parece ser o operador typeof . O único problema é que está terrivelmente quebrado:

  • Ele retorna "object" para null , que pertence ao tipo nulo.
  • Ele retorna "function" para objects que podem ser chamados, que pertencem ao tipo de object.
  • Ele pode retornar (quase) tudo o que desejar para objects não padrão que não podem ser chamados. Por exemplo, o IE parecia gostar de "unknown" . Os únicos resultados proibidos são "function" e tipos primitivos.

typeof é confiável apenas para primitivos não null . Portanto, uma maneira de verificar se um valor é um object seria garantir que a string retornada por typeof não corresponda a uma primitiva e que o object não seja null . No entanto, o problema é que um padrão futuro poderia introduzir um novo tipo primitivo, e nosso código o consideraria um object. Novos tipos não aparecem com frequência, mas, por exemplo, o ECMAScript 6 introduziu o tipo Symbol.

Portanto, em vez de typeof , eu só recomendo abordagens cujo resultado varia dependendo se o valor é um object ou não. O seguinte pretende ser um

Lista abrangente, mas não exaustiva, de maneiras adequadas de testar se um valor pertence ao tipo de object.

  • Construtor de Object

    O construtor Object coerces o argumento passado para um object. Se já é um object, o mesmo object é retornado.

    Portanto, você pode usá-lo para forçar o valor a um object e comparar estritamente esse object com o valor original.

    A seguinte function requer o ECMAScript 3, que introduziu === :

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

    Eu gosto dessa abordagem porque é simples e autodescritiva, e uma verificação análoga também funciona para booleanos, números e strings. Entretanto, esteja ciente de que o Object global não está sendo sombreado nem alterado.

  • Construtores

    Quando você instancia um construtor, ele pode retornar um valor diferente da instância recém-criada. Mas esse valor será ignorado, a menos que seja um object.

    A seguinte function requer o ECMAScript 3, que permitia que os construtores retornassem não-objects. Antes ECMAScript 3 que jogou um erro, mas try declarações não existiam naquela época.

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

    Embora um pouco menos simples que o exemplo anterior, este não depende de nenhuma propriedade global e, portanto, pode ser o mais seguro.

  • this valor

    Especificações antigas do ECMAScript exigiam que this valor fosse um object. O ECMAScript 3 introduziu o Function.prototype.call , que permitia chamar uma function com um valor arbitrário, mas coagida a um object.

    O ECMAScript 5 introduziu um modo estrito que removeu este comportamento, mas no modo sloppy ainda podemos (mas provavelmente não devemos) confiar nele.

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

    Todos os objects comuns possuem um slot interno chamado [[Prototype]], cujo valor determina de qual outro object ele herda. O valor pode ser apenas um object ou null . Portanto, você pode tentar criar um object que herda do valor desejado e verificar se funcionou.

    Tanto Object.getPrototypeOf quanto Object.getPrototypeOf requerem o 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; } 
  • Algumas novas ECMAScript 6 maneiras

    O ECMAScript 6 introduz algumas novas maneiras indiretas de verificar se um valor é um object. Eles usam a abordagem anteriormente vista para passar o valor para algum código que requer um object, envolvido dentro de uma instrução try para capturar erros. Alguns exemplos escondidos, não vale a pena comentar

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

Tente isso

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

Pronto para usar funções para verificar

 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 

Explicação

  • Em Javascript, null , Object , Array , Date e function s são todos objects. Embora, null seja um pouco inventado. Portanto, é melhor verificar primeiro o null , para detectar que não é nulo.

  • A verificação de typeof o === 'object' garante que o é um object. Sem essa verificação, Object.prototype.toString teria sentido, pois retornaria o object para everthing, mesmo para undefined e null ! Por exemplo: toString(undefined) retorna [object Undefined] !

    Após typeof o === 'object' , toString.call (o) é um ótimo método para verificar se o é um object, um object derivado como Array , Date ou uma function .

  • Na function isDerivedObject , verifica se o é uma function. Porque, funciona também como um object, é por isso que está lá. Se não fizer isso, a function retornará como falsa. Exemplo: isDerivedObject(function() {}) retornaria false , mas agora retorna true .

  • Pode-se sempre mudar a definição do que é um object. Então, pode-se alterar essas funções de acordo.


Testes

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

Fui solicitado a fornecer mais detalhes. A maneira mais limpa e compreensível de verificar se a nossa variável é um object é typeof myVar . Ele retorna uma string com um tipo (por exemplo, "object" , "undefined" ).

Infelizmente, Array e null também possuem um object tipo. Para obter apenas objects reais, é necessário verificar a cadeia de inheritance usando o operador instanceof . Ele eliminará null, mas Array possui Object na cadeia de inheritance.

Então a solução é:

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

Pouco tarde … para “objects simples” (quero dizer, como {‘x’: 5, ‘y’: 7}) eu tenho este pequeno trecho:

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

It generates the next output:

 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 

Sempre funciona para mim. If will return “true” only if the type of “o” is “object”, but no null, or array, or function. 🙂

lodash has isPlainObject , which might be what many who come to this page are looking for. It returns false when give a function or array.

When everything else fails, I use this:

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

Isso vai funcionar. It is a function that returns true, false, or possibly null.

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

Return Types

typeof JavaScript constructors and objects (including null ) returns "object"

 console.log(typeof null, typeof [], typeof {}) 
  var isObject = function(obj) { var type = typeof obj; return type === 'function' || type === 'object' && !!obj; }; 

!!obj is shorthand for checking if object is truthy ( to filter out null/undefined)

 if(typeof value === 'object' && value.constructor === Object) { console.log("This is an object"); } 

The Ramda functional library has a wonderful function for detecting JavaScript types.

Paraphrasing the full function :

 function type(val) { return val === null ? 'Null' : val === undefined ? 'Undefined' : Object.prototype.toString.call(val).slice(8, -1); } 

I had to laugh when I realized how simple and beautiful the solution was.

Example usage from Ramda documentation :

 R.type({}); //=> "Object" R.type(1); //=> "Number" R.type(false); //=> "Boolean" R.type('s'); //=> "String" R.type(null); //=> "Null" R.type([]); //=> "Array" R.type(/[Az]/); //=> "RegExp" R.type(() => {}); //=> "Function" R.type(undefined); //=> "Undefined" 

What I like to use is this

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

I think in most of the cases a Date must pass the check as an Object, so I do not filter dates out

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

edit:
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 

ou

 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 

If you are already using AngularJS then it has a built in method which will check if its an object (without accepting null).

 angular.isObject(...) 

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

Mostly typeof obj[index] === 'object' is used, but it will return also function and #document which are an objects. It depends up to you if it need to be included in the result.

Basically you can do a test code that filtering out if a particular elements is an object by checking the output in your console. Here you can run a code just for a sample:

 function cekObject(obj, index) { if (!obj.tagName) { //test case #1 if (typeof obj === 'object') { console.log('obj['+ index +'] is listed as an object'); } } } 
   

    If you would like to check if the prototype for an object solely comes from Object . Filters out String , Number , Array , Arguments , etc.

     function isObject(n) { if (n == null) return false; return Object.prototype.toString.call(n) === '[object Object]'; } 

    Consider – typeof bar === "object" to determine if bar is an object

    Although typeof bar === "object" is a reliable way of checking if bar is an object, the surprising gotcha in JavaScript is that null is also considered an object!

    Therefore, the following code will, to the surprise of most developers, log true (not false) to the console:

    var bar = null; console.log(typeof bar === "object"); // logs true! As long as one is aware of this, the problem can easily be avoided by also checking if bar is null:

    console.log((bar !== null) && (typeof bar === "object")); // logs false To be entirely thorough in our answer, there are two other things worth noting:

    First, the above solution will return false if bar is a function. In most cases, this is the desired behavior, but in situations where you want to also return true for functions, you could amend the above solution to be:

    console.log((bar !== null) && ((typeof bar === "object") || (typeof bar === "function"))); Second, the above solution will return true if bar is an array (eg, if var bar = []; ). In most cases, this is the desired behavior, since arrays are indeed objects, but in situations where you want to also false for arrays, you could amend the above solution to be:

    console.log((bar !== null) && (typeof bar === "object") && (toString.call(bar) !== "[object Array]")); However, there’s one other alternative that returns false for nulls, arrays, and functions, but true for objects:

    console.log((bar !== null) && (bar.constructor === Object)); Or, if you’re using jQuery:

    console.log((bar !== null) && (typeof bar === "object") && (! $.isArray(bar)));

    ES5 makes the array case quite simple, including its own null check:

    console.log(Array.isArray(bar));