ce n'est pas facile. Vous devrez faire une boucle sur les propriétés explicitement:

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

    return true;
}

si ECMAScript 5 supporte est disponible, vous pouvez utiliser Object.keys() à la 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 .

C'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) === '{}';
}

question ancienne, mais juste eu le problème. Y compris 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 en profondeur dans 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;
}

je viens de tomber dans 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 était, utilisé 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 ne pas être égal à, Utilisez ceci: JSON.stringify(obj) !== '{}'

Regardez ce JSFiddle

il y a un moyen simple si vous êtes sur un nouveau navigateur. Object.keys(obj).length == 0

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

il utilise Object.keys de ECMAScript 5 (ES5) fonctionnalité si possible pour atteindre la meilleure performance (voir tableau de compatibilité ) et les retombées à l'approche la plus 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 le Résumé pour ce code.

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

j'espère que ça aidera quelqu'un. Acclamations!

1. juste une solution. Votre serveur peut-il générer une propriété spéciale en cas d'absence de données?

   par exemple:

   var a = {empty:true};
   

   alors 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
   

MODIFIER : Si vous utilisez une bibliothèque JSON (F. E. JSON.js) puis vous peut essayer de JSON.coder() la fonction et tester le résultat par rapport à la chaîne de valeurs vide.

Utilisant L'Objet.les touches(obj).la longueur (comme suggéré ci-dessus pour ECMA 5+) est 10 fois plus lente pour les objets vides! gardez à l'ancienne école (...).

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

• (de...à...) est l'option la plus rapide à utiliser!
• objet.les touches(obj).la longueur est 10 fois plus lente pour les objets vides
• JSON.stringify (obj).la longueur est toujours la plus lente (sans surprise)
• objet.getOwnPropertyNames (obj).la longueur est plus longue que L'objet.les touches(obj).la longueur peut être beaucoup plus longue sur certains systèmes.

résultats financiers, utilisation:

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 détaillés des essais et le code d'essai à est-ce que l'objet est vide?

vous pouvez vérifier le nombre de touches de l'objet:

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

un Autre simple, pure JS :)

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

j'utilise ceci.

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 d'isEmptyObject

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

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

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

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

plus d'informations sur http://api.jquery.com/jQuery.isEmptyObject /

vous pouvez utiliser ce code simple qui n'a pas utilisé 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');
}

JSON class and it's functions ( parse and stringify ) sont très utiles mais a quelques problèmes avec IE7 que vous pouvez le corriger avec ce code simple http://www.json.org/js.html .



autre méthode Simple (méthode la plus simple)) :

vous pouvez utiliser cette façon sans utiliser jQuery ou JSON objet.

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

meilleure façon que j'ai trouvé:

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

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

    return false;
}

Travaille 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

L'exemple suivant montre comment tester si un objet JavaScript est vide, si vide, on a pas de propres propriétés.

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

si jQuery et le navigateur web ne sont pas disponibles, il y a aussi une fonction isEmpty dans underscore.js.

_.isEmpty({}) // returns true

de plus, 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, il tournera également la bonne réponse.

de Mon point de vue:

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.

une boucle simple:

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

en plus de la réponse vs:

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

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

c'est jquery + jquery.json

mise en garde! Méfiez-vous de JSON est limitiations.

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

    Beware!! obj is NOT empty!

    obj = {  f:function(){}  }

    JSON.stringify( obj )

    returns

    {}

de Sucre.JS fournit des objets étendus à cette fin. Le code est propre et simple:

Faire un objet étendu:

a = Object.extended({})

vérifier sa taille:

a.size()

une autre solution consiste à utiliser is.js (14ko) par opposition à jquery (32ko), lodash (50ko), ou underscore (16.4 ko). être.js s'est avéré être la bibliothèque la plus rapide parmi les bibliothèques mentionnées ci-dessus qui pourrait être utilisé pour déterminer si un objet est vide.

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

évidemment toutes ces bibliothèques ne sont pas exactement les mêmes donc si vous avez besoin de manipuler facilement le DOM puis jquery pourrait toujours être un bon choix ou si vous avez besoin de plus que la simple vérification de type alors lodash ou underscore pourrait être bon. Comme pour est.js , voici la syntaxe:

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

comme _.isObject() de underscore et lodash , ce n'est pas exclusivement pour objects mais s'applique également à arrays et strings .

sous le capot cette bibliothèque utilise Object.getOwnPropertyNames qui est similaire à Object.keys mais Object.getOwnPropertyNames est un plus complet car il retournera énumérable et non énumérable propriétés comme décrit ici .

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 vous ne voulez pas apporter une bibliothèque (ce qui est compréhensible) et vous savez que vous ne Vérifiez des objets (pas tableaux ou chaînes de caractères) alors la fonction suivante devrait convenir à vos besoins.

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

C'est seulement un peu plus rapide qu'est.js si juste parce que vous ne Vérifiez pas si c'est un objet.

la bonne réponse est:

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

Ce vérifie que:

• l'objet n'a pas de propriétés propres (indépendamment de l'énumérabilité).
• l'objet n'a pas de symbole de propriété propre.
• le prototype de l'objet est exactement Object.prototype .

en d'autres termes, l'objet est indiscernable d'un objet créé avec {} .

je vérifierais s'il y a au moins une clé. Qui suffirait à me dire qu'il n'est pas vide.

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