Verifique se o valor é um objeto em javascript

Como você verifica se um valor é um objeto em javascript?

969
14 дек. definido por Danny Fox 14 de dezembro. 2011-12-14 23:35 '11 às 11:35 PM 2011-12-14 23:35
@ 38 respostas
  • 1
  • 2

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

EDIT: esta resposta dá uma idéia de como investigar as propriedades das variáveis, mas esta não é uma receita à prova de balas (afinal, não há receita!) Para verificar se é um objeto longe disso. Como as pessoas tendem a procurar algo para copiar aqui sem fazer nenhuma pesquisa, eu recomendo que elas recorram a outra, mais aprovada (e correta!) Resposta.

384
14 дек. Resposta é dada por Michael Krelin - hacker 14 dec. 2011-12-14 23:39 '11 às 11:39 2011-12-14 23:39

Se typeof yourVariable === 'object' , é um objeto ou um zero. Se você quiser excluir null, apenas typeof yourVariable === 'object' yourVariable !== null .

border=0
1162
14 дек. A resposta é dada por Chuck 14 de dezembro 2011-12-14 23:40 '11 às 23:40 2011-12-14 23:40

Vamos definir o "objeto" em javascript . De acordo com documentos do MDN , cada valor é um objeto ou um primitivo:

significado primitivo e primitivo

Dados que não são objetos e não possuem métodos. JavaScript tem 5 tipos de dados primitivos: string, number, boolean, null, undefined.

Que primitivo?

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

Qual objeto (ou seja, não primitivo)?

  • Object.prototype
  • tudo vem do Object.prototype
    • Function.prototype
      • Object
      • Function
      • function C(){} - funções definidas pelo usuário
    • C.prototype é uma propriedade protótipo de uma função definida pelo usuário: não é um protótipo de C
      • new C() - "novo" - definição de função do usuário
    • Math
    • Array.prototype
      • matrizes
    • {"a": 1, "b": 2} - objetos criados usando notação literal
    • new Number(3) - wrappers em torno de primitivos
    • ... muito mais ...
  • Object.create(null)
  • tudo vem de Object.create(null)

Como verificar se um valor é um objeto

instanceof si não vai 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]" 

Portanto, eu uso:

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

@ Dan resposta também funciona:

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

já que de acordo com os documentos do MDN :

O construtor de objetos cria um wrapper de objeto para o valor fornecido. Se o valor for nulo ou indefinido, ele criará e retornará um objeto vazio, caso contrário, retornará um objeto do tipo correspondente ao valor fornecido. Se o valor já for um objeto, ele retornará um valor.


A 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 objeto

 // 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({}) 
465
18 марта '14 в 17:44 2014-03-18 17:44 a resposta é dada por Matt Fenwick em 18 de março '14 às 17:44 2014-03-18 17:44

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

 // Is a given variable an object? _.isObject = function(obj) { return obj === Object(obj); }; 
208
05 февр. a resposta é dada Daan 05 fev. 2013-02-05 14:50 '13 às 14:50 2013-02-05 14:50

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

  • "[object Object]" se myVar é um objeto
  • "[object Array]" se myVar é um array
  • e outros

Para mais informações sobre isso e por que é um bom tipo de alternativa, leia este artigo .

158
13 нояб. Resposta dada por Christophe em 13 de nov 2012-11-13 09:20 '12 em 9:20 2012-11-13 09:20

Para verificação simples de um objeto ou matriz sem chamada de função adicional (velocidade). 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 somente os literais do objeto, porque ele retorna false para objetos personalizados, como uma nova data ou um novo objeto 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 
75
17 мая '13 в 14:39 2013-05-17 14:39 a resposta é dada zupa May 17 '13 at 14:39 2013-05-17 14:39

Eu apenas amo:

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

Se o elemento for um objeto JS e não for uma matriz de JS, não será null ... se todos os três forem verdadeiros, retornará true . Se qualquer uma das três condições falhar, o teste > terá um curto-circuito e false será retornado. Se necessário, o teste null pode ser omitido (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

70
08 сент. A resposta é dada pelo jtheletter 08 de setembro 2014-09-08 01:49 '14 às 1:49 2014-09-08 01:49

Com a função Array.isArray :

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

Sem a função Array.isArray :

Só queria saber quantas respostas para as 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, é tão claro e simples, e funciona! Aqui estão 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 um tempo: nem todas as respostas passam neste teste !!! 🙈


Caso você precise verificar se o objeto é uma instância de uma determinada classe, você deve verificar o construtor com sua classe específica, por exemplo:

 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 rigoroso e confiável!


Caso você não crie funções como isDate , isError , isRegExp , etc., você pode considerar 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 objetos (simples ou construídos).


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

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

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

63
10 окт. A resposta é dada por Vladimir Kovpak em 10 de outubro. 2017-10-10 12:21 '17 às 12: 21h de 2017-10-10 12:21

Bem, vamos primeiro dar a você esse conceito antes de responder sua pergunta, em JavaScript, Funções são Objeto, também nulo, Objeto, Matrizes e até Data, então, como você pode ver, não existe uma maneira simples, como typeof obj == = 'objeto', então tudo mencionado acima retornará true , mas existem maneiras de testar isso escrevendo uma função ou usando estruturas JavaScript, bem:

Agora imagine que você tem este objeto, que é um objeto real (não um zero, não uma função ou um array):

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

Limpar o javascript:

 //that 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 dito acima, em seu código, chamando-as, e ele retornará verdadeiro se for um objeto:

 isObject(obj); 

Se você estiver usando uma estrutura JavaScript, eles geralmente preparam essas funções para você, aqui estão algumas delas:

Jquery:

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

Canto:

 angular.isObject(obj); 

Underline e Lodash:

 //(NOTE: in Underscore and Lodash, functions, arrays return true as well but not null) _.isObject(obj); 
27
15 февр. Resposta dada por Alireza em 15 fev. 2017-02-15 16:39 '17 às 4:39 2017-02-15 16:39

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

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

Ele exclui primitivos (primos / NaN / Infinity , cadeias simples, caracteres, true / false , undefined e null ), mas deve retornar true para todo o resto (incluindo objetos Number , Boolean e String ). Observe que o JS não especifica quais objetos "host", como window ou console , devem ser retornados quando usados ​​com typeof , portanto, é difícil cobri-los com essa verificação.

Se você quiser descobrir se algo é um objeto "simples", isto é, ele foi criado como um literal {} ou usando Object.create(null) , você pode fazer isso:

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

Edição 2018 : como o Symbol.toStringTag agora permite personalizar a saída de Object.prototype.toString.call(...) , a função isPlainObject , isPlainObject acima, pode retornar false em alguns casos, mesmo que o objeto tenha iniciado sua vida como um literal. Pode-se argumentar que, por convenção, um objeto com uma tag de string personalizada não é mais um objeto simples, mas isso confundiu ainda mais a definição do que um objeto simples é mesmo em Javascript.

21
19 янв. a resposta é dada último filho 19 de janeiro 2016-01-19 00:12 '16 às 0:12 2016-01-19 00:12

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

  • Ele retorna "object" para null , que é do tipo nulo.
  • Ele retorna "function" para objetos que podem ser chamados que são do tipo objeto.
  • Ele pode retornar (quase) tudo o que deseja para objetos não-padrão não-solicitáveis. Por exemplo, o IE parece ter gostado de "unknown" . Os únicos resultados proibidos são "function" e tipos primitivos.

typeof é confiável apenas para primitivos null . Assim, uma maneira de verificar se um valor é um objeto garantirá que a string retornada por typeof não corresponda à primitiva e que o objeto não seja null . No entanto, o problema é que o padrão futuro pode introduzir um novo tipo primitivo, e nosso código irá considerá-lo como um objeto. Novos tipos não aparecem com frequência, mas, por exemplo, o ECMAScript 6 introduz um tipo de caractere.

Portanto, em vez de typeof eu recomendo apenas abordagens, cujo resultado depende se esse valor é um objeto ou não. O seguinte pretende ser

Uma lista completa, mas não exaustiva, de formas corretas de verificar se um valor pertence a um tipo de objeto.

  • Construtor de Object

    O construtor Object força o argumento passado para o objeto. Se já é um objeto, o mesmo objeto é retornado.

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

    A seguinte função requer o ECMAScript 3, que é inserido em === :

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

    Eu gosto dessa abordagem porque ela é simples e autodescritiva, e uma verificação semelhante também funcionará para Booleanos, números e cadeias de caracteres. No entanto, lembre-se de que o Object global não Object sombreado nem alterado.

  • <strong> Construtores

    Quando você cria uma instância de um construtor, ele pode retornar um valor diferente da instância que você acabou de criar. Mas esse valor será ignorado se não for um objeto.

    A seguinte função requer o ECMAScript 3, que permite que os construtores retornem não-objetos. Antes do ECMAScript 3 executar um erro, mas as try não existiam então.

     function isObject(value) {  return new function() { return value; }() === value; } 

    Embora o bit seja menos simples que o anterior, ele não depende de nenhuma propriedade global e, portanto, pode ser o mais seguro.

  • this valor

    Nas antigas especificações do ECMAScript, this é necessário para ser um objeto. No ECMAScript 3, Function.prototype.call introduzido, o que permite chamar uma função com um valor arbitrário, mas forçada para um objeto.

    O ECMAScript 5 introduz o modo estrito que elimina esse comportamento, mas em um modo impreciso, ainda podemos (mas talvez não devamos) confiar nele.

     function isObject(value) {  return function() { return this === value; }.call(value); } 
  • [[Protótipo]]

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

    Tanto Object.getPrototypeOf quanto Object.getPrototypeOf requerem o ECMAScript 5.

     function isObject(value) {  try { Object.create(value); return value !== null; } catch(err) { return false; } } 
     function isObject(value) {  function Constructor() {} Constructor.prototype = value; return Object.getPrototypeOf(new Constructor()) === value; } 
  • Algumas novas maneiras ECMAScript 6

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

    16
    28 авг. responder a Oriol 28 ago. 2016-08-28 03:48 '16 às 3:48 2016-08-28 03:48

Experimente

 if (objectName instanceof Object == false) { alert('Not an object'); } else { alert('An object'); } 
14
09 мая '12 в 14:43 2012-05-09 14:43 a resposta é dada Talha 09 de maio, '12 at 14:43 2012-05-09 14:43

Pronto para usar recursos para testar

12
18 нояб. a resposta é dada por Inanc Gumus 18 de novembro 2016-11-18 02:43 '16 às 2:43 am 2016-11-18 02:43
 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 informações. A maneira mais clara e compreensível de verificar se a nossa variável é um objeto é typeof myVar . Ele retorna uma string com um tipo (por exemplo, "object" , "undefined" ).

Infelizmente, Array e null também são do tipo type. Para obter apenas objetos reais, você precisa verificar a cadeia de herança usando o operador instanceof . Ele eliminará null, mas Array possui um Object na cadeia de herança.

Então, a solução:

 if (myVar instanceof Object  !(myVar instanceof Array)) { // code for objects } 
11
10 июня '16 в 10:41 2016-06-10 10:41 a resposta é dada por Kania em 10 de junho de '16 às 10:41 2016-06-10 10:41

Um pouco atrasado ... para "objetos simples" (quero dizer, por exemplo {'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'); } 

Ele gera a seguinte saída:

 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 

Isso sempre funciona para mim. Se "true" for retornado, somente se o tipo "o" for "objeto", mas não nulo, ou uma matriz ou função. :)

10
25 окт. resposta dada por Emilio Grisolía em 25 de outubro. 2015-10-25 19:26 '15 às 19:26 2015-10-25 19:26

Meu Deus, há muita confusão em outras respostas.

Resposta curta

typeof anyVar == 'object' anyVar instanceof Object !(anyVar instanceof Array)

Para verificar isso, basta executar as seguintes declarações no console do Chrome.

Caso 1

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

Caso 2

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

Caso 3

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

explicação

Bom Vamos ver

typeof anyVar == 'object' retorna true de três candidatos - [], {} and null ,

anyVar instanceof Object reduz esses candidatos para dois - [], {}

!(anyVar instanceof Array) reduz para apenas um - {}

Rolo de bateria por favor!

Com isso, você já deve ter aprendido como verificar uma matriz em JavaScript.

9
24 сент. A resposta é dada kushalvm 24 set . 2018-09-24 14:45 18h às 14h45 . 2018-09-24 14:45

O lodash tem isPlainObject , e isso pode ser o que muitos que chegam a esta página estão procurando. Ele retorna false quando dá uma função ou um array.

8
20 окт. Resposta dada por Pat em 20 Out 2014-10-20 22:33 '14 às 10:33 pm 2014-10-20 22:33

Tipos de retorno

construtores e objetos JavaScript de tipo (incluindo null ) retorna "object"

 console.log(({}).constructor) // returns a function with name "Object" console.log(([]).constructor) // returns a function with name "Array" console.log((null).constructor) //throws an error because null does not actually have a property 

Apresentando Function.name

Function.name retorna um nome de função somente leitura ou "anonymous" para fechamentos.

 function isAnObject(obj) { if(obj==null) return false; return obj.constructor.name.toLowerCase() === "object" } console.log(isAnObject({})) // return true console.log(isAnObject([])) // returns false console.log(isAnObject(null)) // return false 

Nota Function.name может не работать в IE. Https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name#Browser_compatibility

7
ответ дан Erisan Olasheni 21 июля '18 в 19:27 2018-07-21 19:27