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

var a = {};

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

ECMA 5+ :

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

Sin embargo, tenga en cuenta que esto crea una matriz innecesaria (el valor de retorno de keys).

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

Subrayado :

_.isEmpty({}); // true

Hoek

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

ExtJS

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

AngularJS (versión 1)

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

Ramda

R.isEmpty({}); // true

No hay una manera fácil de hacer esto. Tendrá 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 ECMAScript 5 está disponible, puede usar Object.keys()en su lugar:

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

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

Esta es mi solución preferida:

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

Puedes usar Underscore.js .

_.isEmpty({}); // true

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

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

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

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

Me encontré con 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 igual a, use esto: JSON.stringify(obj) !== '{}'

Mira este JSFiddle

Antigua pregunta, pero acaba 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 cambio, solo profundice en el código de JQuery , y obtendrá la respuesta:

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

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

Actuación

Hoy 2020.01.17 realizo pruebas en MacOs HighSierra 10.13.6 en Chrome v79.0, Safari v13.0.4 y Firefox v72.0, para las soluciones elegidas.

Conclusiones

• soluciones basadas en for-in (A, J, L, M) son más rápidas
• soluciones basadas en JSON.stringify (B, K) son lentas
• Sorprendentemente, también la solución basada en Object(N) es lenta

Detalles

A continuación en el fragmento se presentan 15 soluciones. Si desea ejecutar una prueba de rendimiento en su máquina, haga clic AQUÍ .

var log = (s,f) => console.log(`${s} --> {}:${f({})}  {k:2}:${f({k:2})}`);

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

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

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

function D(obj) {
  return Object.entries(obj).length === 0;
}

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

function F(obj) {
  return Object.keys(obj).length === 0 && obj.constructor === Object;
}

function G(obj) {
  return typeof obj === "undefined" || !Boolean(Object.keys(obj)[0]);
}

function H(obj) {
  return Object.entries(obj).length === 0 && obj.constructor === Object;
}

function I(obj) {
  return Object.values( obj  ).every( val => typeof val === "undefined" );
}

function J(obj) {
  for (const key in obj) {
    if (hasOwnProperty.call(obj, key)) {
      return false
    }
  }
  return true;
}

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

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

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

  return true;
}

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

function N(obj) {
  return Object.getOwnPropertyNames(obj).length === 0 &&
  Object.getOwnPropertySymbols(obj).length === 0 &&
  Object.getPrototypeOf(obj) === Object.prototype; 
}

function O(obj) {
  return !(Object.getOwnPropertyNames != undefined ? Object.getOwnPropertyNames(obj).length != 0 : (function(){for(var key in obj) break; return (key != null) && (key != undefined);})())
}

log('A',A);
log('B',B);
log('C',C);
log('D',D);
log('E',E);
log('F',F);
log('G',G);
log('H',H);
log('I',I);
log('J',J);
log('K',K);
log('L',L);
log('M',M);
log('N',N);
log('O',O);

¡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 en Node, Chrome, 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 es siempre la más lenta (no es sorprendente)
• Object.getOwnPropertyNames (obj) .length tarda más que Object.keys (obj) .length puede ser mucho más largo en algunos sistemas.

En términos de rendimiento, 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 detallados de las pruebas y el código de prueba en ¿Está el objeto vacío?

Puede verificar el recuento de las teclas de objeto:

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

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

   Por ejemplo:

   var a = {empty:true};

   Luego puede verificarlo fácilmente en su código de devolución de llamada AJAX.

2. Otra forma de verificarlo:

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

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

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

Utiliza Object.keysde ECMAScript 5 (ES5) funcionalidad si es posible para lograr el mejor rendimiento (ver tabla de compatibilidad ) y retrocesos con el enfoque más compatible para los 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 esencia de este código.

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

Espero que ayude a alguien. ¡Salud!

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

puede usar la implementación jQuery de isEmptyObject

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

El siguiente ejemplo muestra cómo probar si un objeto JavaScript está vacío, si por vacío queremos decir 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

Según la especificación ES2017 en Object.entries () , la verificación es simple usando cualquier navegador moderno:

Object.entries({}).length === 0

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

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

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

Lea más en http://api.jquery.com/jQuery.isEmptyObject/

Me gustaría comprobar si tiene al menos una clave. Eso sería suficiente para decirme que no está vacío.

typeof obj !== "undefined" && Boolean(Object.keys(obj)[0])

Debajo del capó, todos los métodos de verificación vacíos en todas las bibliotecas usan claves de objeto para verificar la lógica. Es una forma extraña de hacer que sea comprensible, lo que puede poner en un método, descrito aquí .

for(key in obj){
   //your work here.
 break;
}

Que ha evolucionado en ES5 , ahora simplemente puede verificar la longitud de las claves del objeto, utilizando el Object.Keysmétodo que toma su objeto como parámetro:

if(Object.keys(obj).length > 0){
 //do your work here
}

O si está utilizando Lodash (debe ser) entonces.

 _.isEmpty(obj) //==true or false

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 stringify ) son muy útiles, pero tiene algunos problemas con IE7 que puede solucionar con este código simple http://www.json.org/js.html .

Otra forma simple (forma más simple):
puede usar esta forma 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

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

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 se implementen Object.keys()actualmente.

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 supone que el parámetro de entrada sea un objeto. Para una lista o cadena o indefinida, también dará la respuesta correcta.

¡Consideración! 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

    ¡¡Tener cuidado!! ¡obj NO está vacío!

    obj = {f: función () {}}

    JSON.stringify (obj)

    devoluciones

    {}

La respuesta correcta es:

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

Esto verifica que:

• El objeto no tiene propiedades propias (independientemente de la 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 {}.

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

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

Hacer un objeto extendido:

a = Object.extended({})

Comprueba su tamaño:

a.size()