Après une demande AJAX, mon application peut parfois renvoyer un objet vide, comme:

var a = {};

Comment puis-je vérifier si c'est le cas?

ECMA 5+ :

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

Notez cependant que cela crée un tableau inutile (la valeur de retour de keys).

Pré-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

Souligner :

_.isEmpty({}); // true

Hoek

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

ExtJS

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

AngularJS (version 1)

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

Ramda

R.isEmpty({}); // true

Il n'y a pas de moyen facile de le faire. Vous devrez parcourir les propriétés explicitement:

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

    return true;
}

Si la prise en charge d' ECMAScript 5 est disponible, vous pouvez utiliser à la Object.keys()place:

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

Pour ceux d'entre vous qui ont le même problème mais utilisent jQuery, vous pouvez utiliser jQuery.isEmptyObject .

Ceci est ma solution préférée:

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

Vous pouvez utiliser Underscore.js .

_.isEmpty({}); // true

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

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

Que diriez-vous d'utiliser JSON.stringify? Il est presque disponible dans tous les navigateurs modernes.

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

Je viens de rencontrer une situation similaire. Je ne voulais pas utiliser JQuery et je voulais le faire en utilisant du Javascript pur.

Et ce que j'ai fait, c'est utiliser la condition suivante, et cela a fonctionné pour moi.

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

Pour différent de, utilisez ceci: JSON.stringify(obj) !== '{}'

Découvrez ce JSFiddle

Vieille question, mais vient d'avoir le problème. Inclure JQuery n'est pas vraiment une bonne idée si votre seul but est de vérifier si l'objet n'est pas vide. Au lieu de cela, juste profondément dans le code de JQuery , et vous obtiendrez la réponse:

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

Il existe un moyen simple si vous utilisez un navigateur plus récent. Object.keys(obj).length == 0

Performance

Aujourd'hui 2020.01.17 j'effectue des tests sur MacOs HighSierra 10.13.6 sur Chrome v79.0, Safari v13.0.4 et Firefox v72.0, pour les solutions choisies.

Conclusions

• les solutions basées sur for-in(A, J, L, M) sont les plus rapides
• les solutions basées sur JSON.stringify(B, K) sont lentes
• étonnamment, la solution basée sur Object(N) est lente

Détails

Ci-dessous en extrait sont présentées 15 solutions. Si vous souhaitez exécuter un test de performances sur votre machine, cliquez sur ICI .

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

L'utilisation d'Object.keys (obj) .length (comme suggéré ci-dessus pour ECMA 5+) est 10 fois plus lente pour les objets vides! garder avec l'option old school (for ... in).

Testé sous Node, Chrome, Firefox et IE 9, il devient évident que pour la plupart des cas d'utilisation:

• (for ... in ...) est l'option la plus rapide à utiliser!
• Object.keys (obj) .length est 10 fois plus lent pour les objets vides
• JSON.stringify (obj) .length est toujours le plus lent (pas surprenant)
• Object.getOwnPropertyNames (obj) .length prend plus de temps que Object.keys (obj) .length peut être beaucoup plus long sur certains systèmes.

En termes de performances, utilisez:

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

ou

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

Voir les résultats de test détaillés et le code de test sur Is object empty?

Vous pouvez vérifier le nombre de clés d'objet:

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

1. Juste une solution de contournement. Votre serveur peut-il générer des propriétés spéciales en cas d'absence de données?

   Par exemple:

   var a = {empty:true};

   Ensuite, vous pouvez facilement le vérifier dans votre code de rappel AJAX.

2. Une autre façon de le vérifier:

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

EDIT : Si vous utilisez une bibliothèque JSON (par exemple JSON.js), vous pouvez essayer la fonction JSON.encode () et tester le résultat par rapport à une chaîne de valeur vide.

J'ai créé une fonction complète pour déterminer si l'objet est vide.

Il utilise Object.keysde ECMAScript 5 (ES5) fonctionnalité si possible pour obtenir les meilleures performances (voir tableau de compatibilité ) et à la plus solutions de repli approche compatible pour les moteurs plus anciens (navigateurs).

Solution

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

Voici l' essentiel de ce code.

Et voici le JSFiddle avec démonstration et un test simple.

J'espère que cela aidera quelqu'un. À votre santé!

J'utilise ça.

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

Par exemple:

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;

d'ici

Mise à jour

OU

vous pouvez utiliser l'implémentation jQuery de isEmptyObject

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

L'exemple suivant montre comment tester si un objet JavaScript est vide, si par vide nous voulons dire qu'il n'a pas de propriétés propres.

Le script fonctionne sur 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

Selon la spécification ES2017 sur Object.entries () , la vérification est simple en utilisant n'importe quel navigateur moderne -

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

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

jQuery a une fonction spéciale isEmptyObject()pour ce cas:

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

En savoir plus sur http://api.jquery.com/jQuery.isEmptyObject/

J'irais vérifier s'il a au moins une clé. Cela suffirait à me dire que ce n'est pas vide.

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

Sous le capot, toutes les méthodes de vérification vides dans toutes les bibliothèques utilisent des clés d'objet pour vérifier la logique. C'est une façon étrange de le rendre compréhensible, que vous pouvez mettre dans une méthode, décrite ici .

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

Qui a évolué en ES5 , maintenant, vous pouvez simplement vérifier la longueur des clés de l'objet, en utilisant une Object.Keysméthode qui prend votre objet comme paramètre:

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

Ou si vous utilisez Lodash (vous devez l'être) alors.

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

vous pouvez utiliser ce code simple qui n'utilisait pas jQuery ou d'autres bibliothèques

var a=({});

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

La classe JSON et ses fonctions ( parse et stringify ) sont très utiles mais ont quelques problèmes avec IE7 que vous pouvez résoudre avec ce code simple http://www.json.org/js.html .

Autre méthode simple (méthode la plus simple):
vous pouvez utiliser cette méthode sans utiliser d' objet jQuery ou 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

Le meilleur moyen que j'ai trouvé:

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

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

    return false;
}

Fonctionne pour:

    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

Ma prise:

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

Juste, je ne pense pas que tous les navigateurs implémentent Object.keys()actuellement.

Si jQuery et le navigateur Web ne sont pas disponibles, il existe également une fonction isEmpty dans underscore.js.

_.isEmpty({}) // returns true

En outre, il ne suppose pas que le paramètre d'entrée soit un objet. Pour une liste ou une chaîne ou non définie, cela donnera également la bonne réponse.

Caveat! Méfiez-vous des limitations 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 ) );

affiche

    Il faut se méfier!! obj n'est PAS vide!

    obj = {f: function () {}}

    JSON.stringify (obj)

    Retour

    {}

La bonne réponse est:

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

Cela vérifie que:

• L'objet n'a pas de propriétés propres (quelle que soit l'énumération).
• L'objet n'a pas de propre symbole de propriété.
• Le prototype de l'objet est exactement Object.prototype.

En d'autres termes, l'objet est indiscernable de celui créé avec {}.

En plus de la réponse de Thevs:

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

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

c'est jquery + jquery.json

Sugar.JS fournit des objets étendus à cet effet. Le code est propre et simple:

Créez un objet étendu:

a = Object.extended({})

Vérifiez sa taille:

a.size()