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?
if( Object.entries(a).length > 0){ //do }
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?
if( Object.entries(a).length > 0){ //do }
Réponses:
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
_.isEmpty({}); // true
Hoek.deepEqual({}, {}); // true
Ext.Object.isEmpty({}); // true
angular.equals({}, {}); // true
R.isEmpty({}); // true
Object.keys(new Date()).length === 0
; donc cette réponse peut être trompeuse.
(new Date()).constructor === Date
, ou inversement, ({}).constructor === Object
.
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.constructor
peut être facilement forgé. Exemple: function Foo() {} Foo.prototype.constructor = Object; (new Foo()).constructor === Object // 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;
}
isEmpty()
, donc elle devrait retourner false
si elle a une propriété
Pour ceux d'entre vous qui ont le même problème mais utilisent jQuery, vous pouvez utiliser jQuery.isEmptyObject .
underscore.js
...
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
Object.keys(new Date()).length === 0
; donc cette réponse peut être trompeuse.
new Date()
n'est pas un objet. nd = new Date(); nd.constructor === Object;
résulte en false
.
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/
Object.getOwnPropertyNames(new Date()).length === 0
; donc cette réponse peut être trompeuse.
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
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 key
avec une valeur qui, à nouveau, comme une propriété nommée length
qui n'est pas nulle. Horrible!
Object.keys(new Date()).length === 0
; donc cette réponse peut être trompeuse.
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
for-in
(A, J, L, M) sont les plus rapidesJSON.stringify
(B, K) sont lentesObject
(N) est lenteCi-dessous en extrait sont présentées 15 solutions. Si vous souhaitez exécuter un test de performances sur votre machine, cliquez sur ICI .
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:
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.keys
est 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?
Vous pouvez vérifier le nombre de clés d'objet:
if (Object.keys(a).length > 0) {
// not empty
}
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.
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.
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)
toSource
proprié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!
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.
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 obtenir les meilleures performances (voir tableau de compatibilité ) et à la plus solutions de repli approche compatible pour les moteurs plus anciens (navigateurs).
/**
* 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é!
Object.keys(new Date()).length === 0
; donc cette réponse peut être trompeuse.
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;
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
Object.keys
ou Object.values
?
function isEmpty(obj) {
for(var i in obj) { return false; }
return true;
}
Object
avec une méthode à travers la chaîne de prototype, car c'est énumérable et l' for in
instruction boucle à travers les propriétés énumérables.
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])
false
valeur? le résultat sera false
incorrect.
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.Keys
mé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
if (!obj && obj !== 0)
.
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.
Object.keys(new Date()).length === 0
; donc cette réponse peut être trompeuse.
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:
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
$.isEmptyObject()
, ne perdez pas de cycles avec des conversions non évidentes.
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()