objetos - Compruebe si un valor es un objeto en JavaScript

prototype javascript ejemplos (30)

¿Cómo verifica si un valor es un objeto en JavaScript?

Listo para usar funciones para la comprobación.

Explicación

En Javascript, null , Object , Array , Date y function s son todos objetos. Aunque, null es poco artificial. Por lo tanto, es mejor verificar primero el null , para detectar que no es nulo.
La comprobación de typeof o === ''object'' garantiza que o es un objeto. Sin esta verificación, Object.prototype.toString tendría sentido, ya que devolvería el objeto para todo, incluso para undefined y null . Por ejemplo: toString(undefined) devuelve [object Undefined] !
Después de typeof o === ''object'' comprobación de typeof o === ''object'' , toString.call (o) es un método excelente para verificar si o es un objeto, un objeto derivado como Array , Date o una function .
En la función isDerivedObject , comprueba si la o es una función. Porque, función también un objeto, es por eso que está ahí. Si no lo hizo, la función volverá como falsa. Ejemplo: isDerivedObject(function() {}) devolvería false , sin embargo, ahora devuelve true .
Uno siempre puede cambiar la definición de lo que es un objeto. Por lo tanto, uno puede cambiar estas funciones en consecuencia.

Pruebas

Con la función `Array.isArray` :

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

Sin función `Array.isArray` :

Me sorprende la cantidad de votos a favor de respuestas incorrectas 😮
Solo 1 respuesta pasó mis pruebas !!! Aquí he creado mi versión simplificada:

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

En cuanto a mí, es claro y simple, ¡y simplemente funciona! Aquí mis pruebas:

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

UNA VEZ MÁS: ¡no todas las respuestas pasan estas pruebas! 🙈

En caso de que necesite verificar que el objeto es una instancia de una clase en particular, debe verificar el constructor con su clase en particular, como:

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

prueba simple:

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

Como resultado, tendrás un código estricto y robusto!

En caso de que no cree funciones como isDate , isError , isRegExp , etc., puede considerar la opción de usar estas funciones generalizadas:

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

no funcionará correctamente para todos los casos de prueba mencionados anteriormente, pero es lo suficientemente bueno para todos los objetos (planos o construidos).

isObject no funcionará en el caso de Object.create(null) debido a la implementación interna de Object.create que se explica here pero puede usar isObject en una implementación más sofisticada:

¡Ya hay un paquete creado en npm v1 basado en esta implementación! ¡Y funciona para todos los casos de prueba descritos anteriormente! 🙂

Tipos de retorno

Tipo de constructores de JavaScript y objetos (incluidos null) retornos"object"

console.log(typeof null, typeof [], typeof {})

Comprobando sus constructores

Comprobación de su constructorpropiedad devuelve función con sus nombres.

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

Introduciendo Function.name

Function.namedevuelve un nombre de solo lectura de una función o "anonymous"para cierres.

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

Código final

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 podría no funcionar en IE https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name#Browser_compatibility

De acuerdo, primero le daremos este concepto antes de responder a su pregunta, en JavaScript Las funciones son Objeto, también nulo, Objeto, Arrays e incluso Fecha, por lo que verá que no hay una forma simple como typeof obj === ''objeto'', por lo que todo lo mencionado anteriormente devolverá verdadero , pero hay formas de verificarlo escribiendo una función o utilizando marcos de JavaScript, OK:

Ahora, imagine que tiene este objeto que es un objeto real (no nulo o función o matriz):

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

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

Simplemente puede usar una de estas funciones como se indica arriba en su código llamándolas y devolverá verdadero si es un objeto:

isObject(obj);

Si está utilizando un marco de JavaScript, normalmente han preparado este tipo de funciones para usted, estas son algunas de ellas:

jQuery:

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

Angular:

angular.isObject(obj);

Subrayado y Lodash:

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

Depende de lo que quieras decir con "es un objeto". Si quieres todo lo que no es primitivo , es decir, cosas en las que puedes establecer nuevas propiedades, esto debería hacer el truco:

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

Excluye las primitivas (números sin formato / NaN / Infinity , cadenas sin formato, símbolos, true / false , undefined y null ), pero debe devolver verdadero para todo lo demás (incluidos los objetos Number , Boolean y String ). Tenga en cuenta que JS no define qué objetos "host", como la window o la console , deberían devolver cuando se usan con typeof , por lo que es difícil cubrirlos con un cheque como este.

Si desea saber si algo es un objeto "simple", es decir, se creó como un literal {} o con Object.create(null) , puede hacer esto:

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

Edit 2018 : Dado que Symbol.toStringTag ahora permite personalizar la salida de Object.prototype.toString.call(...) , la función isPlainObject anterior puede devolver false en algunos casos, incluso cuando el objeto comenzó su vida como un literal. Podría decirse que, por convención, un objeto con una etiqueta de cadena personalizada ya no es exactamente un objeto simple, pero esto ha enturbiado aún más la definición de lo que es un objeto plano en Javascript.

El underscore.js oficial underscore.js utiliza esta comprobación para averiguar si algo es realmente un objeto.

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

Intente usar typeof(var) y / o var instanceof something .

EDITAR: Esta respuesta da una idea de cómo examinar las propiedades de la variable, pero no es una receta a prueba de balas (después de todo, ¡no hay ninguna receta en absoluto!) Para verificar si es un objeto, ni mucho menos. Dado que las personas tienden a buscar algo para copiar desde aquí sin hacer ninguna investigación, recomiendo encarecidamente que recurran a la otra respuesta más votada (¡y correcta!).

La forma más razonable de verificar el tipo de un valor parece ser el tipo de operador. El único problema es que está horriblemente roto:

Devuelve "object" para null , que pertenece al tipo nulo.
Devuelve "function" para objetos que se pueden llamar, que pertenecen al tipo de objeto.
Puede devolver (casi) cualquier cosa que desee para objetos no estándar que no se pueden llamar. Por ejemplo, parece que a IE le gusta "unknown" . Los únicos resultados prohibidos son "function" y tipos primitivos.

typeof solo es confiable para primitivas no null . Por lo tanto, una forma de verificar si un valor es un objeto sería garantizar que la cadena devuelta por typeof no se corresponda con una primitiva y que el objeto no sea null . Sin embargo, el problema es que un estándar futuro podría introducir un nuevo tipo primitivo, y nuestro código lo consideraría un objeto. Los nuevos tipos no aparecen con frecuencia, pero por ejemplo, ECMAScript 6 introdujo el tipo de Símbolo.

Por lo tanto, en lugar de typeof , solo recomiendo enfoques cuyo resultado varía dependiendo de si el valor es un objeto o no. Lo siguiente pretende ser un

Lista completa pero no exhaustiva de formas adecuadas para probar si un valor pertenece al tipo de objeto.

Constructor de Object
El constructor de Object obliga al argumento pasado a un objeto. Si ya es un objeto, se devuelve el mismo objeto.
Por lo tanto, puede usarlo para forzar el valor a un objeto y comparar estrictamente ese objeto con el valor original.
La siguiente función requiere ECMAScript 3, que introdujo === :
function isObject(value) { /* Requires ECMAScript 3 or later */ return Object(value) === value; }
Me gusta este enfoque porque es simple y auto-descriptivo, y una verificación análoga también funcionará para booleanos, números y cadenas. Sin embargo, tenga en cuenta que se basa en que el Object global no está sombreado ni alterado.
Constructores
Cuando crea una instancia de un constructor, puede devolver un valor diferente al de la instancia recién creada. Pero ese valor será ignorado a menos que sea un objeto.
La siguiente función requiere ECMAScript 3, que permite a los constructores devolver objetos que no son objetos. Antes de ECMAScript 3 que arrojó un error, pero las declaraciones de try no existían en ese entonces.
function isObject(value) { /* Requires ECMAScript 3 or later */ return new function() { return value; }() === value; }
Aunque es un poco menos simple que el ejemplo anterior, este no se basa en ninguna propiedad global y, por lo tanto, podría ser el más seguro.
this valor
Las especificaciones antiguas de ECMAScript requerían que this valor fuera un objeto. ECMAScript 3 introdujo Function.prototype.call , que permitía llamar a una función con un valor arbitrario, pero obligado a un objeto.
ECMAScript 5 introdujo un modo estricto que eliminó este comportamiento, pero en modo descuidado todavía podemos (pero posiblemente no deberíamos) confiar en él.
function isObject(value) { /* Requires ECMAScript 3 or later in sloppy mode */ return function() { return this === value; }.call(value); }
[[Prototipo]]
Todos los objetos ordinarios tienen una ranura interna llamada [[Prototipo]], cuyo valor determina de qué otro objeto hereda. El valor solo puede ser un objeto o null . Por lo tanto, puede intentar crear un objeto que herede del valor deseado y verificar si funcionó.
Tanto Object.create como Object.getPrototypeOf requieren 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; }
Algunas nuevas formas de ECMAScript 6
ECMAScript 6 introduce nuevas formas indirectas de verificar si un valor es un objeto. Utilizan el enfoque visto anteriormente para pasar el valor a algún código que requiere un objeto, envuelto dentro de una declaración de try para detectar errores. Algunos ejemplos ocultos, no vale la pena comentar.
function isObject(value) { /* Requires ECMAScript 6 or later */ try { Object.setPrototypeOf({}, value); return value !== null; } catch(err) { return false; } }
function isObject(value) { /* Requires ECMAScript 6 or later */ try { new WeakSet([value]); return true; } catch(err) { return false; } }

Nota: intencionalmente Object.getPrototypeOf(value) algunos enfoques como Object.getPrototypeOf(value) (ES5) y Reflect methods (ES6) porque llaman métodos internos esenciales que podrían hacer cosas desagradables, por ejemplo, si value es un proxy. Por razones de seguridad, mis ejemplos solo hacen referencia al value sin acceder directamente.

Me gusta simplemente

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

Si el elemento es un objeto JS, y no es una matriz JS, y no es null ... si los tres demuestran ser verdad, devuelva true . Si cualquiera de las tres condiciones falla, la prueba de && se cortocircuitará y se devolverá false . La prueba null se puede omitir si se desea (dependiendo de cómo se use 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 simplemente verificar contra Object o Array sin función adicional llamada (velocidad). Como también publicado here .

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 solo para literales de objetos, ya que devuelve falso para objetos personalizados, como la nueva fecha o el nuevo 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

Prueba esto

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

Si typeof yourVariable === ''object'' , es un objeto o un valor nulo. Si desea excluir nulo, simplemente convierta su yourVariable !== null && typeof yourVariable === ''object'' .

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

"[object Object]" si myVar es un objeto
"[object Array]" si myVar es una matriz
etc.

Para obtener más información sobre esto y por qué es una buena alternativa a typeof, consulte este artículo .

Vamos a definir "objeto" en Javascript . Según los documentos de MDN , cada valor es un objeto o una primitiva:

primitivo, valor primitivo
Un dato que no es un objeto y no tiene ningún método. JavaScript tiene 5 tipos de datos primitivos: cadena, número, booleano, nulo, indefinido.

¿Qué es un primitivo?

3
''abc''
true
null
undefined

¿Qué es un objeto (es decir, no un primitivo)?

Object.prototype
Todo desciende de Object.prototype
- Function.prototype
  - Object
  - Function
  - function C(){} - funciones definidas por el usuario
- C.prototype - la propiedad prototipo de una función definida por el usuario: este no es el prototipo de C s
  - new C() - "new" -ing una función definida por el usuario
- Math
- Array.prototype
  - matrices
- {"a": 1, "b": 2} - objetos creados usando notación literal
- new Number(3) - envoltorios alrededor de primitivas
- ... muchas otras cosas ...
Object.create(null)
Todo desciende de un Object.create(null)

Cómo comprobar si un valor es un objeto.

instanceof por sí mismo no funcionará, porque se pierde dos casos:

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

typeof x === ''object'' no funcionará, debido a falsos positivos ( null ) y falsos negativos (funciones):

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

Object.prototype.toString.call no funcionará, debido a los falsos positivos de todas las primitivas:

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

Así que uso:

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

La respuesta de @ Daan también parece funcionar:

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

Porque, según la documentación de MDN :

El constructor de objetos crea una envoltura de objeto para el valor dado. Si el valor es nulo o no definido, creará y devolverá un objeto vacío; de lo contrario, devolverá un objeto de un tipo que corresponde al valor dado. Si el valor ya es un objeto, devolverá el valor.

Una tercera forma en que parece funcionar (no estoy seguro de si es del 100%) es usar Object.getPrototypeOf que lanza una excepción si su argumento no es un 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({})

Cuando todo lo demás falla, uso esto:

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

Depende del caso de uso, si no queremos que la matriz y las funciones sean un Objeto, podemos usar las funciones integradas underscore.js.

function xyz (obj) { if (_.isObject(obj) && !_.isFunction(obj) && !.isArray(obj)) { // now its sure that obj is an object } }

Dios mío, demasiada confusión en otras respuestas.

Respuesta corta

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

Para probar esto, simplemente ejecute las siguientes declaraciones en la consola de 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

Explicación

Está bien. Vamos a descomponerlo

typeof anyVar == ''object''se devuelve verdadero de tres candidatos - [], {} and null,

anyVar instanceof Object reduce estos candidatos a dos - [], {}

!(anyVar instanceof Array) se reduce a uno solo {}

Rollos de tambor por favor!

Por esto, es posible que ya hayas aprendido a verificar Array en Javascript.

Lo que me gusta usar es esto

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

Creo que en la mayoría de los casos, una Fecha debe pasar la verificación como un Objeto, así que no filtro las fechas

Poco tarde ... para "objetos simples" (quiero decir, como {''x'': 5, ''y'': 7}) Tengo este pequeño fragmento:

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

Genera la siguiente salida:

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

Siempre me funciona. If devolverá "true" solo si el tipo de "o" es "object", pero no null, o array, o function. :)

Si ya está utilizando AngularJS, entonces tiene un método incorporado que comprobará si es un objeto (sin aceptar el valor nulo).

angular.isObject(...)

En su mayoría typeof obj[index] === ''object''se utiliza, pero se devolverá también functiony #documentque son objetos. Depende de usted si necesita ser incluido en el resultado.

Básicamente, puede hacer un código de prueba que filtre si un elemento en particular es un objeto verificando el resultado en su consola. Aquí puede ejecutar un código solo para una muestra:

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

<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.2.3/jquery.min.js"></script> <script> function updateFilters() { var object = $(''.j-image''); $(''.juicer-feed'').empty(); for(var index in object) { cekObject(object[index], index); }; } </script> <ul class="juicer-feed" data-feed-id="chetabahana" data-after="updateFilters()"></ul> <script src="https://assets.juicer.io/embed.js"></script>

Encontré una "nueva" forma de hacer este tipo de comprobación de tipo de esta pregunta SO: ¿Por qué instanceof devuelve false para algunos literales?

a partir de eso, creé una función para la verificación de tipos de la siguiente manera:

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

entonces puedes simplemente hacer

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

esto se prueba en Chrome 56, Firefox 52, Microsoft Edge 38, Internet Explorer 11, Opera 43

editar:
si también quiere comprobar si una variable es nula o no definida, puede usar esto en su lugar:

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

actualización del comentario de inanc: desafío aceptado: D

Si quieres perder objetos comparativos puedes intentarlo de esta manera:

De esa manera, puedes hacer como el comentario de inanc:

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

Esto funcionará. Es una función que devuelve verdadero, falso o posiblemente nulo.

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

La biblioteca funcional Ramda tiene una función maravillosa para detectar tipos de JavaScript.

Parafraseando la función completa :

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

Tuve que reírme cuando me di cuenta de lo sencilla y hermosa que era la solución.

Ejemplo de uso de la documentation 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"

Si desea comprobar si la prototypeuna objectviene únicamente de Object. Filtra String, Number, Array, Arguments, etc.

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

lodash tiene isPlainObject , que podría ser lo que muchos de los que isPlainObject esta página están buscando. Devuelve falso cuando se le da una función o matriz.

use typeof(my_obj)will indica qué tipo de variable es.

si es objeto se mostrará ''objeto''

función JS simple,

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

P.ej:

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

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

!!obj es taquigrafía para verificar si el objeto es verdadero (para filtrar nulo / indefinido)

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

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

Me pidieron que proporcione más detalles. La forma más limpia y comprensible de verificar si nuestra variable es un objeto es typeof myVar. Devuelve una cadena con un tipo (por ejemplo "object", "undefined").

Desafortunadamente, Array y NULL también tienen un tipo object. Para tomar solo objetos reales, es necesario verificar la cadena de herencia usando el instanceofoperador. Se eliminará el valor nulo, pero Array tiene Objeto en la cadena de herencia.

Así que la solución es:

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