objetos - ¿Cómo pruebo un objeto JavaScript vacío?

recorrer array de objetos javascript

Question

Después de una solicitud AJAX, a veces mi aplicación puede devolver un objeto vacío, como:

var a = {};

¿Cómo puedo comprobar si ese es el caso?

Answer 1

1. Sólo una solución. ¿Puede su servidor generar alguna propiedad especial en caso de que no haya datos?

   Por ejemplo:

   var a = {empty:true};

   Luego puedes verificarlo fácilmente en tu código de devolución de llamada AJAX.

2. Otra forma de comprobarlo:

   if (a.toSource() === "({})")  // then ''a'' is empty

EDITAR : Si usa cualquier biblioteca JSON (fe JSON.js), puede probar la función JSON.encode () y probar el resultado contra una cadena de valor vacía.

Answer 2

¡Advertencia! Cuidado con las limitaciones de JSON.

javascript:
  obj={  f:function(){}  };
  alert( "Beware!! obj is NOT empty!/n/nobj = {  f:function(){}  }" + 
               "/n/nJSON.stringify( obj )/n/nreturns/n/n" +
                        JSON.stringify( obj ) );

muestra

Beware!! obj is NOT empty! obj = { f:function(){} } JSON.stringify( obj ) returns {}

Answer 3

¡Usar Object.keys (obj) .length (como se sugirió anteriormente para ECMA 5+) es 10 veces más lento para objetos vacíos! mantener con la vieja escuela (para ... en) opción.

Probado bajo Node, Chrom, Firefox e IE 9, se hace evidente que para la mayoría de los casos de uso:

• (para ... en ...) es la opción más rápida de usar!
• Object.keys (obj) .length es 10 veces más lento para objetos vacíos
• JSON.stringify (obj) .length siempre es el más lento (no sorprendente)
• Object.getOwnPropertyNames (obj) .length tarda más tiempo que Object.keys (obj) .length puede ser mucho más largo en algunos sistemas.

En cuanto al rendimiento de la línea de fondo, use:

function isEmpty(obj) { 
   for (var x in obj) { return false; }
   return true;
}

o

function isEmpty(obj) {
   for (var x in obj) { if (obj.hasOwnProperty(x))  return false; }
   return true;
}

Vea los resultados de las pruebas detalladas y el código de prueba en ¿Está vacío el objeto?

Answer 4

¿Qué hay de usar JSON.stringify? Está casi disponible en todos los navegadores modernos.

function isEmptyObject(obj){
    return JSON.stringify(obj) === ''{}'';
}

Answer 5

Además de la respuesta de Thevs:

var o = {};
alert($.toJSON(o)==''{}''); // true

var o = {a:1};
alert($.toJSON(o)==''{}''); // false

es jquery + jquery.json

Answer 6

Antigua pregunta, pero acabo de tener el problema. Incluir JQuery no es realmente una buena idea si su único propósito es verificar si el objeto no está vacío. En su lugar, solo profundiza en el código de JQuery y obtendrás la respuesta:

function isEmptyObject(obj) {
    var name;
    for (name in obj) {
        if (obj.hasOwnProperty(name)) {
            return false;
        }
    }
    return true;
}

Answer 7

El siguiente ejemplo muestra cómo probar si un objeto de JavaScript está vacío, si por vacío significa que no tiene propiedades propias.

El script funciona en ES6.

const isEmpty = (obj) => {
    if (obj === null ||
        obj === undefined ||
        Array.isArray(obj) ||
        typeof obj !== ''object''
    ) {
        return true;
    }
    return Object.getOwnPropertyNames(obj).length === 0;
};
console.clear();
console.log(''-----'');
console.log(isEmpty(''''));           // true
console.log(isEmpty(33));           // true
console.log(isEmpty([]));           // true
console.log(isEmpty({}));           // true
console.log(isEmpty({ length: 0, custom_property: [] })); // false
console.log(''-----'');
console.log(isEmpty(''Hello''));      // true
console.log(isEmpty([1, 2, 3]));    // true
console.log(isEmpty({ test: 1 }));  // false
console.log(isEmpty({ length: 3, custom_property: [1, 2, 3] })); // false
console.log(''-----'');
console.log(isEmpty(new Date()));   // true
console.log(isEmpty(Infinity));     // true
console.log(isEmpty(null));         // true
console.log(isEmpty(undefined));    // true

Answer 8

Esta es mi solución preferida:

var obj = {};
return Object.keys(obj).length; //returns 0 if empty or an integer > 0 if non-empty

Answer 9

Estoy usando esto.

function isObjectEmpty(object)
{
  var isEmpty = true;
  for(keys in object)
  {
     isEmpty = false;
     break; // exiting since we found that the object is not empty
  }
  return isEmpty;
}

P.ej:

var myObject = {}; // Object is empty
var isEmpty  = isObjectEmpty(myObject); // will return true;

// populating the object
myObject = {"name":"John Smith","Address":"Kochi, Kerala"}; 

// check if the object is empty
isEmpty  = isObjectEmpty(myObject); // will return false;

de aquí

Actualizar

O

puedes usar la implementación jQuery de isEmptyObject

function isEmptyObject ( obj ) {
        var name;
        for ( name in obj ) {
            return false;
        }
        return true;
    }

Answer 10

Hay una forma simple si estás en un navegador más nuevo. Object.keys(obj).length == 0

Answer 11

He creado una función completa para determinar si el objeto está vacío.

Utiliza la funcionalidad developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… de ECMAScript 5 (ES5) si es posible para lograr el mejor rendimiento (consulte la tabla de compatibilidad ) y utiliza el enfoque más compatible para motores más antiguos (navegadores).

Solución

/**
 * Returns true if specified object has no properties,
 * false otherwise.
 *
 * @param {object} object
 * @returns {boolean}
 */
function isObjectEmpty(object)
{
    if (''object'' !== typeof object) {
        throw new Error(''Object must be specified.'');
    }

    if (null === object) {
        return true;
    }

    if (''undefined'' !== Object.keys) {
        // Using ECMAScript 5 feature.
        return (0 === Object.keys(object).length);
    } else {
        // Using legacy compatibility mode.
        for (var key in object) {
            if (object.hasOwnProperty(key)) {
                return false;
            }
        }
        return true;
    }
}

Aquí está la Gist de este código.

Y aquí está el JSFiddle con demostración y una prueba simple.

Espero que ayude a alguien. ¡Aclamaciones!

Answer 12

Iría para comprobar si tiene al menos una clave. Eso bastaría para decirme que no está vacío.

Boolean(Object.keys(obj)[0])

Answer 13

La mejor manera que encontré:

function isEmpty(obj)
{
    if (!obj)
    {
        return true;
    }

    if (!(typeof(obj) === ''number'') && !Object.keys(obj).length)
    {
        return true;
    }

    return false;
}

Trabaja para:

    t1: {} -> true
    t2: {0:1} -: false
    t3: [] -> true
    t4: [2] -> false
    t5: null -> true
    t6: undefined -> true
    t7: "" -> true
    t8: "a" -> false
    t9: 0 -> true
    t10: 1 -> false

Answer 14

La respuesta correcta es:

const isEmptyObject = obj =>
  Object.getOwnPropertyNames(obj).length === 0 &&
  Object.getOwnPropertySymbols(obj).length === 0 &&
  Object.getPrototypeOf(obj) === Object.prototype;

Esto comprueba que:

• El objeto no tiene propiedades propias (independientemente de la posibilidad de enumeración).
• El objeto no tiene símbolos de propiedad propios.
• El prototipo del objeto es exactamente Object.prototype .

En otras palabras, el objeto es indistinguible de uno creado con {} .

Answer 15

Me acabo de encontrar una situación similar. No quería usar JQuery, y quería hacerlo usando Javascript puro.

Y lo que hice fue usar la siguiente condición y funcionó para mí.

var obj = {};
if(JSON.stringify(obj) === ''{}'') { //This will check if the object is empty
   //Code here..
}

Para no ser igual a, use esto: JSON.stringify(obj) !== ''{}''

Echa un vistazo a este JSFiddle

Answer 16

Mi toma:

function isEmpty(obj) {
    return !Object.keys(obj).length > 0;
}

var a = {a:1, b:2}
var b = {}

console.log(isEmpty(a)); // false
console.log(isEmpty(b)); // true

Simplemente, no creo que todos los navegadores implementen Object.keys() actualmente.

Answer 17

No hay una manera fácil de hacer esto. Tendrás que recorrer las propiedades explícitamente:

function isEmpty(obj) {
    for(var prop in obj) {
        if(obj.hasOwnProperty(prop))
            return false;
    }

    return true;
}

Si el soporte de ECMAScript 5 está disponible, puede usar Object.keys() lugar:

function isEmpty(obj) {
    return Object.keys(obj).length === 0;
}

Answer 18

Otra alternativa es usar is.js (14kB) en lugar de jquery (32kB), lodash (50kB) o underscore (16.4kB). is.js demostró ser la biblioteca más rápida entre las bibliotecas antes mencionadas que podría usarse para determinar si un objeto está vacío.

http://jsperf.com/check-empty-object-using-libraries

Obviamente, todas estas bibliotecas no son exactamente iguales, por lo que si necesita manipular fácilmente el DOM, entonces jquery puede ser una buena opción o si necesita algo más que la comprobación de tipo, entonces lodash o el underscore pueden ser buenos. En cuanto a is.js , aquí está la sintaxis:

var a = {};
is.empty(a); // true
is.empty({"hello": "world"}) // false

Al igual que _.isObject() guiones bajos y de _.isObject() , esto no es exclusivamente para objects sino que también se aplica a arrays y strings .

Bajo el capó, esta biblioteca está usando Object.getOwnPropertyNames que es similar a Object.keys pero Object.getOwnPropertyNames es más completo ya que devolverá propiedades enumerables y no enumerables como se describe here .

is.empty = function(value) {
    if(is.object(value)){
        var num = Object.getOwnPropertyNames(value).length;
        if(num === 0 || (num === 1 && is.array(value)) || (num === 2 && is.arguments(value))){
            return true;
        }
        return false;
    } else {
        return value === '''';
    }
};

Si no desea traer una biblioteca (lo cual es comprensible) y sabe que solo está revisando objetos (no arreglos o cadenas), la siguiente función debe ser adecuada para sus necesidades.

function isEmptyObject( obj ) {
    return Object.getOwnPropertyNames(obj).length === 0;
}

Esto es solo un poco más rápido que is.js, aunque solo porque no estás comprobando si es un objeto.

Answer 19

Otra forma simple, pura JS :)

if (JSON.stringify(pathParams) === ''{}'')

Answer 20

Para aquellos de ustedes que tienen el mismo problema pero usan jQuery, pueden usar jQuery .

Answer 21

Podrías comprobar el recuento de las claves del objeto:

if (Object.keys(a).length > 0) {
    // not empty
}

Answer 22

Puedes usar Underscore .

_.isEmpty({}); // true

Answer 23

Si jQuery y el navegador web no están disponibles, también hay una función isEmpty en underscore.js.

_.isEmpty({}) // returns true

Además, no asume que el parámetro de entrada sea un objeto. Para una lista o cadena o indefinido, también se convertirá en la respuesta correcta.

Answer 24

Un simple bucle:

var is_empty = true;
for(var i in obj) {
    is_empty = false;
    break;
}

Answer 25

jQuery tiene una función especial isEmptyObject() para este caso:

jQuery.isEmptyObject({}) // true
jQuery.isEmptyObject({ foo: "bar" }) // false

Lea más en jQuery

Answer 26

Sugar.JS proporciona objetos extendidos para este propósito. El código es limpio y simple:

Hacer un objeto extendido:

a = Object.extended({})

Compruebe su tamaño:

a.size()

Answer 27

ECMA 5+ :

// because Object.keys(new Date()).length === 0;
// we have to do some additional check
Object.keys(obj).length === 0 && obj.constructor === Object

Pre-ECMA 5:

function isEmpty(obj) {
    for(var prop in obj) {
        if(obj.hasOwnProperty(prop))
            return false;
    }

    return JSON.stringify(obj) === JSON.stringify({});
}

jQuery :

jQuery.isEmptyObject({}); // true

lodash

_.isEmpty({}); // true

Underscore :

_.isEmpty({}); // true

Hoek

Hoek.deepEqual({}, {}); // true

ExtJS

Ext.Object.isEmpty({}); // true

AngularJS (versión 1)

angular.equals({}, {}); // true

Ramda

R.isEmpty({}); // true

Answer 28

puede usar este código simple que no usó jQuery u otras bibliotecas

var a=({});

//check is an empty object
if(JSON.stringify(a)==''{}'') {
    alert(''it is empty'');
} else {
    alert(''it is not empty'');
}

La clase JSON y sus funciones ( analizar y clasificar ) son muy útiles, pero tienen algunos problemas con IE7 que puede solucionar con este simple código http://www.json.org/js.html .

Otra forma simple (la manera más simple):
se puede usar de esta manera sin usar jQuery o el objeto JSON .

var a=({});

function isEmptyObject(obj) {
    if(typeof obj!=''object'') {
        //it is not object, so is not empty
        return false;
    } else {
        var x,i=0;
        for(x in obj) {
            i++;
        }
        if(i>0) {
            //this object has some properties or methods
            return false;
        } else {
            //this object has not any property or method
            return true;
        }
    }
}

alert(isEmptyObject(a));    //true is alerted

Answer 29

function isEmpty(obj) {
  for(var i in obj) { return false; }
  return true;
}

Answer 30

if(Object.getOwnPropertyNames(obj).length === 0){
  //is empty
}

vea http://bencollier.net/2011/04/javascript-is-an-object-empty/