Pregunta Verificar si un valor es un objeto en JavaScript


¿Cómo se comprueba si un valor es un Objeto en JavaScript?


844
2017-12-14 20:35


origen


Respuestas:


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

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


330
2017-12-14 20:39



Si typeof yourVariable === 'object', es un objeto o nulo. Si desea excluir nulo, solo hágalo yourVariable !== null && typeof yourVariable === 'object'.


1015
2017-12-14 20:40



Definamos "objeto" en Javascript. De acuerdo con la Documentos de MDN, cada valor es un objeto o un primitivo:

valor primitivo y 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 es un primitivo)?

  • Object.prototype
  • todo descendió 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: esto es no  Cs prototipo
      • new C() - "nuevo" -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 primitivos
    • ... muchas otras cosas ...
  • Object.create(null)
  • todo descendió de un Object.create(null)

Cómo verificar si un valor es un objeto

instanceof por sí solo no funcionará, porque 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 falsos positivos para todas las primitivas:

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

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

Entonces yo 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 el Documentos de MDN:

El constructor de objetos crea un contenedor de objetos para el valor dado. Si el valor es nulo o indefinido, creará y devolverá un objeto vacío; de lo contrario, devolverá un objeto de un tipo que corresponda al valor dado. Si el valor ya es un objeto, devolverá el valor.


Una tercera forma que parece funcionar (no estoy seguro si es 100%) es usar Object.getPrototypeOf cual arroja 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({})

429
2018-03-18 14:44



El oficial underscore.js usa este control para descubrir si algo es realmente un objeto

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

173
2018-02-05 11:50



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

  • "[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, echa un vistazo a este artículo.


148
2017-11-13 06:20



Me gusta simplemente:

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

Si el artículo es un objeto JS, y no es una matriz JS, y no es null... si los tres son verdaderos, regresa true. Si alguna de las tres condiciones falla, el && la prueba se cortocircuitará y false Será devuelto. los null la prueba 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


65
2017-09-07 22:49



Para simplemente verificar contra Object o Array sin función adicional, llame (velocidad). Como también publicado aquí.

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 Objeto, ya que devuelve falso para objetos personalizados, como nueva Fecha o 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

61
2018-05-17 11:39



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 sorprendió la cantidad de votaciones ascendentes por respuestas incorrectas
 Solamente 1 respuesta ¡pasé mis exámenes! 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 solo 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 esta prueba!


En caso de que necesite verificar que el objeto es instancia de clase particular tienes que verificar constructor con tu clase 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 vayas a crear funciones como isDate, isError, isRegExp, etc. puede considerar la opción de utilizar 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 (simples o construidos).


isObject no funcionará en caso de Object.create(null) debido a la implementación interna de Object.create que se explica aquí pero puedes usar isObject en una implementación más 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;
};

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


56
2017-10-10 09:21



De acuerdo, déjenos darle este concepto primero antes de responder a su pregunta, en JavaScript las funciones son Object, también null, Object, Arrays e incluso Date, de modo que como ve hay no de una manera simple como typeof obj === 'object', entonces todo lo mencionado arriba lo hará devolver verdadero, pero hay formas de verificarlo escribiendo una función o usando frameworks 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';
}

o

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

o

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

o

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

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

isObject(obj);

Si está utilizando un marco de JavaScript, generalmente 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);

Subrayar y Lodash:

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

26
2018-02-15 13:39