Comment tester un objet JavaScript vide?


3114

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?


7
Utilisez-vous le script JSON.js? Ou toute autre bibliothèque JSON. Ensuite, vous pouvez utiliser la fonction JSON.encode () pour convertir var en chaîne, puis la tester.
Thevs

if( Object.entries(a).length > 0){ //do }
Muhammad Shahzad

Réponses:


5431

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

22
Voici le test de performance entre jQuery et underscore jsperf.com/isempty-vs-isemptyobject/6
Mikhail

20
Object.keys(new Date()).length === 0; donc cette réponse peut être trompeuse.
cjbarth

6
Au lieu des choses stringifying vous pouvez également profiter de ce fait: (new Date()).constructor === Date, ou inversement, ({}).constructor === Object.
John Nelson

2
angular.equals ({}, {});
Jeremy A. West

11
Object.keys()ne vérifie pas les propriétés non énumérables ou les symboles. Vous devez utiliser Object.getOwnPropertyNames()et à la Object.getOwnPropertySymbols()place. C'est également Object.getPrototypeOf()la bonne façon d'obtenir le prototype d'un objet. obj.constructorpeut être facilement forgé. Exemple: function Foo() {} Foo.prototype.constructor = Object; (new Foo()).constructor === Object // true.
Jesse

863

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

56
Cela fonctionne très bien, ou plus simplement: function isEmpty (object) {for (var i in object) {return true; } return false; }
Nicholas Kreidberg

36
Le vrai et le faux ne devraient-ils pas être inversés dans cette fonction?
namtax

25
@namtax: non - la fonction est nommée isEmpty(), donc elle devrait retourner falsesi elle a une propriété
Christoph

6
un objet vide étendra la classe d'objet par défaut mais si le prototype d'objet est modifié, votre fonction simplifiée échouera, considérez: Object.prototype.a = 'hi'; var obj = {}; alerte (obj.a); // affiche "hi" isEmpty (obj) // renvoie false
venimus

29
Vous ne devez pas utiliser le deuxième exemple car il s'agit de la complexité temporelle O (n) et de la complexité spatiale O (n), tandis que le premier est O (1).
Brian

572

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


43
HEY! Je viens de passer quelques heures à déboguer des problèmes IE 8 pour constater que c'était jQuery.isEmptyObject qui causait le problème. Il retourne vrai si l'objet est vide.
MFD3000

162
Pourquoi publiez-vous une réponse incluant jQuery si la question ne concerne pas du tout jQuery?
Eru

47
Je sais que c'est un vieux commentaire, mais je me pose la question @ MFD3000, car le docu dit: retourne vrai, si l'objet est vide (comme son nom l'indique)
Александр Фишер

21
inclure jQuery pour une telle tâche de base n'est pas ce que j'appellerais la bonne réponse. Il est vrai qu'aujourd'hui jQuery est presque omniprésent, mais il ne faut pas oublier qu'il est construit autour d'un langage très capable lui-même.
Pablo Mescher

54
Snobisme typique de JS dans ces commentaires. Tout le monde sait qu'une énorme proportion de JavaScript sur le Web est écrite sur jQuery, il est donc parfaitement acceptable de fournir ici une solution pour jQuery s'il a déjà une méthode intégrée pour tester les objets. Il est probable que des milliers de développeurs à la recherche d'aide trouveront cette réponse utile. Personne n'a dit que c'était la seule façon de le faire. Je remarque que personne n'agit de manière élitiste à propos du gars qui a posté une solution à utiliser underscore.js...
BadHorsie

277

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

1
Problème de compatibilité avec IE9 BTW. developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
doublejosh

3
@Jero Franzani: non ça ne
marche

La longueur Object.keys ({}). Est 10 fois plus lente que l'option (for ... in ...) - je suggère de l'éviter comme moyen de tester si un objetc est vide.
davidhadas

10
Object.keys(new Date()).length === 0; donc cette réponse peut être trompeuse.
cjbarth

new Date()n'est pas un objet. nd = new Date(); nd.constructor === Object;résulte en false.
Pors

204

Vous pouvez utiliser Underscore.js .

_.isEmpty({}); // true

19
Ou vous pouvez utiliser lodash est vide ( lodash.com/docs#isEmpty ), mais en quoi est-ce différent de l'utilisation d'une solution jQuery - vous devez toujours installer une bibliothèque supplémentaire. Je pense qu'une solution javascript vanille est l'intention.
tfmontague

10
C'est différent si vous voulez utiliser JS sur le backend avec Node.js. Peu de gens voudront utiliser jQuery (une bibliothèque frontale utilisée principalement pour les manipulations DOM) sur le backend.
Nahn

3
@tfmontague underscore est très courant sur les applications de nœuds, presque aussi omniprésent que jQ est côté client. J'avais déjà besoin d'un soulignement mais je ne savais pas qu'il avait cette fonction
rw-nandemo

5
Underscore est remplacé par lodash. Utilisez-le à la place.
demisx

2
Faites juste attention aux types Date, isEmpty renvoie toujours true pour Date, voir github.com/jashkenas/underscore/issues/445
mentat

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

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


5
Cela inclut les propriétés non énumérables, si vous vous en souciez.

La longueur Object.getOwnPropertyNames ({}). Est 10 fois plus lente que l'option (pour ... dans ...) - je suggère de l'éviter comme moyen de tester si un objetc est vide.
davidhadas

4
Object.getOwnPropertyNames(new Date()).length === 0; donc cette réponse peut être trompeuse.
cjbarth

80

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

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

23
return (JSON.stringify (obj) == '{}')
Vic

26
C'est lent et la vitesse compte pour ce type d'utilitaire. Test de perf rapide ici: jsperf.com/empty-object-test

1
Ceci est une option très lente - je suggère d'utiliser plutôt l'option (pour ... dans)
davidhadas

2
Et cela ne fonctionne pas pour les objets qui contiennent des fonctions.
Felix Kling

1
Il générera également une erreur s'il y a une référence circulaire dans l'objet. C'est donc lent, peu fiable et peut générer des erreurs et casser tout le reste. Aucune raison de l'utiliser jamais.
Burak

62

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


4
Échouera pour les objets avec des références circulaires car JSON.stringify lève spécifiquement une exception pour eux.
Pedro Montoto García

1
@ PedroMontotoGarcía Ok et comment un objet vide aura-t-il une référence circulaire?
KthProg

8
Si l'objet n'est pas vide (et cela devrait fonctionner pour eux aussi).
Pedro Montoto García

Cela semble avoir déjà été mentionné par @Ateszki et c'est l'un des moyens les plus lents de vérifier si un objet n'est pas vide.
cwadding

Oh oui .. je l'ai raté. J'ai rencontré une situation où je voulais atteindre ce javascript, et après un peu de réflexion, j'ai compris de cette façon. @Ateszki, Même moi, comme vous l'avez fait. :-) Btw, il y avait beaucoup de réponses à ce sujet, et donc j'ai raté votre réponse.
Anish Nair

60

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

5
Cela n'est utile que si un autre processus n'a pas ajouté de prototype à votre objet de base. Pour que cela fonctionne vraiment, vous devez tester obj.hasOwnProperty (nom)
mpemburn

1
Cela n'ajoute rien à la réponse de Christoph de 2009.
Dan Dascalescu

39

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


1
D'où vient la keyspropriété?

2
C'est une méthode standard dans ECMAScript 5.1
téléchargement le

1
Comment le commentaire ci-dessus peut-il avoir 4 votes positifs? Oui,Object.keys c'est une méthode standard mais les objets n'ont pas de propriété keys. Donc, ce code signalera tout objet comme vide, sauf qu'il se trouve accidentellement qu'une propriété est nommée keyavec une valeur qui, à nouveau, comme une propriété nommée lengthqui n'est pas nulle. Horrible!
scravy

Object.keys(new Date()).length === 0; donc cette réponse peut être trompeuse.
cjbarth

11
@scravy Object est l'objet de classe. L'objet a une méthode statique nommée 'clés' qui accepte un objet comme argument. Cette méthode renvoie un tableau de chaînes où les chaînes sont des noms de propriété. developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
Sgnl

35

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

entrez la description de l'image ici

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 .

entrez la description de l'image ici


beaucoup de cela n'a pas de sens parce que vous basez tout sur un retour de faux et / ou de vrai. Parfois, la programmation nécessite une instruction if ou un opérateur ternaire. juste pour info
Christian Matthew

1
C'est la meilleure réponse, merci, la première solution fonctionne comme un charme
Carlos Jesus Arancibia Taborga

33

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?


Object.keysest lent, mais moins de code. Sur une petite page, où cela s'appelle ... peut-être 10 fois ... Est-ce que ce sera encore plus lent compte tenu du temps d'analyse supplémentaire du code supplémentaire?
yankee

32

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

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

8
Pourquoi voudriez-vous ajouter un commentaire pour une réponse qui a déjà été donnée et donner une réponse pire? stackoverflow.com/a/32108184/4229159 et c'est la 1ère réponse d' avril
Alejandro Vales

Comment faire si j'ai un très gros objet et que je le fais sur chaque boucle juste pour voir si l'objet était vide?
StefansArya

27
  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.


6
toSource()n'est pas standard et ne fonctionne pas dans IE ou Opera (et potentiellement d'autres navigateurs que je n'ai pas vérifiés)
Christoph

4
@Thevs: vous avez peut-être une copie différente de la version actuelle d'ECMA-262, mais la mienne ne répertorie pas une toSourcepropriété dans la section 15.2.4; selon MDC, il a été introduit dans JS1.3 (c'est-à-dire Netscape Navigator 4.06), mais ce n'est PAS dans ECMA-262, 3e édition!
Christoph

4
@Thevs: eh bien, au moins 2 fournisseurs importants de navigateurs ne l'ont pas implémenté, ce n'est donc pas une norme de facto, et comme ce n'est pas dans ECMA-262, ce n'est pas un vrai non plus ...
Christoph

4
Même quand cela fonctionne, toSource()c'est une façon horrible de le faire (comme c'est JSON.encode()). Il doit construire une chaîne représentant votre objet entier pour vérifier simplement s'il est vide. Il y a le surcoût de la conversion de choses en chaînes, mais en plus, il faudra convertir un million de choses si votre objet a un million de propriétés, alors qu'en fait, en regarder une seule vous fera savoir qu'il n'est pas vide.
Jasper

4
@Thevs les frais généraux sont plus importants, même s'ils peuvent être (je ne suis pas sûr que ce soit en toutes circonstances) dans le même ordre de grandeur. Cependant, cette réponse implique de retourner faux dès qu'une propriété différente est trouvée, ce qui rend l'histoire différente tous ensemble ...
Jasper

25

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


3
Cela échoue pour un nullobjet.

Salut @torazaburo! Merci d'avoir pris note! J'ai mis à jour toutes les sources avec une implémentation correcte.
Slava Fomin II

1
La longueur Object.keys ({}). Est 10 fois plus lente que l'option (for ... in ...) - je suggère de l'éviter comme moyen de tester si un objetc est vide.
davidhadas

1
Object.keys(new Date()).length === 0; donc cette réponse peut être trompeuse.
cjbarth

19

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

salut. lorsque vous testez cette fonction avec un nombre ou booléen true ou false, retournez true et ce n'est pas un résultat correct. isObjectEmpty (true). isObjectEmpty (false). isObjectEmpty (1)
iman

2
Nous vérifions si l'objet est vide, pas si le type de données est un objet. Dans votre cas, pour vérifier si c'est un objet, nous avons besoin de quelque chose comme if (typeof === "object") {...}
kiranvj

15

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


15

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

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

3
Y a-t-il un avantage à l'utiliser sur Object.keysou Object.values?
faintsignal

@faintsignal en utilisant ceux-ci sont parfaitement bien. Je viens d'ajouter des entrées car je ne les ai pas trouvées dans les commentaires.
Vikrant

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

4
Cela indiquera également vrai, lorsque, par exemple, une bibliothèque JavaScript s'étend Objectavec une méthode à travers la chaîne de prototype, car c'est énumérable et l' for ininstruction boucle à travers les propriétés énumérables.
viam0Zah


12

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

1
que faire si la première clé renvoie une falsevaleur? le résultat sera falseincorrect.
Jimmy Obonyo Abor

J'ai testé pour ça. Pouvez-vous donner un exemple de travail?
Tudor Morar

1
ceci est court et concis, mais entraînera une erreur d'exécution si l'objet n'est pas défini
Mrinmoy

11

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

Bien que ce soit correct comme une façon étrange de faire une instruction if - cela confondra probablement quelqu'un qui maintiendra le code après vous.
Soren

10


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

JSON.stringifyla solution échoue si l'objet contient des propriétés non stringables telles que des fonctions ou "indéfinies", bien que ce soit un cas limite.

10

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

3
Je dirais que 0 n'est pas vide car c'est en fait un nombre. tout le reste semble bon, mais la correction est facile. dans la première instruction if, ajoutez ceci. if (!obj && obj !== 0).
mjwrazor

9

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.


2
Object.keys(new Date()).length === 0; donc cette réponse peut être trompeuse.
cjbarth

3
Cela dépend si vous considérez qu'une date est toujours "pleine" bien qu'elle n'ait jamais exposé de clés. Mais je suis d'accord que si c'est votre plan, l'ajout d'une vérification d'instance supplémentaire pour le constructeur Date est une bonne option.
NiKo


7

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

    {}

7

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


6

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


Je n'aime pas utiliser JSON car il ne peut pas fonctionner avec des structures d'objets circulaires.
itdoesntwork

2
Si votre page charge jQuery puis utilisez $.isEmptyObject(), ne perdez pas de cycles avec des conversions non évidentes.
skierpage

6

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()
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.