Comment tester un objet JavaScript vide?

après une requête AJAX, parfois mon application peut retourner un objet vide, comme:

var a = {};

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

1973
demandé sur robsch 2009-03-25 04:39:45
la source

30 ответов

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

trait de Soulignement :

_.isEmpty({}); // true

Hoek

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

ExtJS

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

AngularJS (version 1)

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

Ramda

R.isEmpty({}); // true
3275
répondu Adam Zerner 2017-04-13 21:45:25
la source

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;
}
755
répondu Christoph 2014-08-29 14:30:56
la source

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

541
répondu Erik Töyrä 2010-05-19 18:07:51
la source

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
189
répondu dhruvio 2014-07-12 11:46:49
la source

vous pouvez utiliser Underscore.js .

_.isEmpty({}); // true
186
répondu Baggz 2016-01-21 18:54:39
la source
if(Object.getOwnPropertyNames(obj).length === 0){
  //is empty
}

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

104
répondu es cologne 2013-11-06 17:48:25
la source

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

function isEmptyObject(obj){
    return JSON.stringify(obj) === '{}';
}
63
répondu Ateszki 2015-03-18 12:31:43
la source

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;
}
52
répondu Jonathan Petitcolas 2017-05-22 20:32:50
la source

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

43
répondu Anish Nair 2015-04-14 07:45:44
la source

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

24
répondu download 2012-04-29 23:25:48
la source

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!

20
répondu Slava Fomin II 2017-04-26 02:42:07
la source
  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.

17
répondu Thevs 2013-03-04 16:40:11
la source

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?

16
répondu davidhadas 2017-05-23 14:47:31
la source

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

if (Object.keys(a).length > 0) {
    // not empty
}
16
répondu Ashutosh Ranjan 2017-06-30 15:22:50
la source

un Autre simple, pure JS :)

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

15
répondu Leon Gaban 2018-01-26 22:01:29
la source

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;
    }
14
répondu kiranvj 2013-03-22 11:50:12
la source
function isEmpty(obj) {
  for(var i in obj) { return false; }
  return true;
}
10
répondu Lightness Races in Orbit 2011-11-01 12:26:19
la source

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 /

8
répondu 2011-01-25 17:25:42
la source



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
8
répondu iman 2013-09-03 08:34:43
la source

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
8
répondu DiegoAraujo 2017-03-15 16:32:58
la source

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
8
répondu GibboK 2018-07-20 15:38:56
la source

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.

7
répondu jichi 2014-01-14 07:02:57
la source

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.

6
répondu NiKo 2011-10-31 17:39:19
la source

une boucle simple:

var is_empty = true;
for(var i in obj) {
    is_empty = false;
    break;
}
5
répondu Vad 2015-04-10 13:32:10
la source

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

3
répondu starikovs 2010-02-26 15:33:27
la source

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

    {}
3
répondu Ekim 2011-05-24 05:52:50
la source

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()
3
répondu mikemaccana 2012-08-16 13:46:12
la source

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.

3
répondu cwadding 2017-05-23 15:18:27
la source

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 {} .

3
répondu Jesse 2018-06-05 04:27:38
la source

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])
3
répondu Tudor Morar 2018-09-11 13:35:16
la source

Autres questions sur javascript json