Comment tester un objet JavaScript vide?
Après une demande AJAX, mon application peut parfois retourner un objet vide, tel que:
var a = {};
Comment puis-je vérifier si c'est le cas?
ECMA 7+ :
// because Object.keys(new Date()).length === 0;
// we have to do some additional check
Object.entries(obj).length === 0 && obj.constructor === Object
ECMA 5+ :
// because Object.keys(new Date()).length === 0;
// we have to do some additional check
Object.keys(obj).length === 0 && obj.constructor === Object
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
Il n'y a pas de moyen facile de faire cela. Vous devrez explicitement parcourir les propriétés:
function isEmpty(obj) {
for(var prop in obj) {
if(obj.hasOwnProperty(prop))
return false;
}
return true;
}
Si ECMAScript 5 support 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 qui 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) === '{}';
}
Vieille question, mais juste eu 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, approfondissez 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;
}
Je viens de rencontrer une situation similaire. Je ne voulais pas utiliser JQuery et je voulais le faire en 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 pas égal à, utilisez ceci: JSON.stringify(obj) !== '{}'
Découvrez ceci JSFiddle
Il existe un moyen simple si vous utilisez un navigateur plus récent .Object.keys(obj).length == 0
J'ai créé une fonction complète pour déterminer si l'objet est vide.
Il utilise si possible la fonctionnalité Object.keys from ECMAScript 5 (ES5) pour obtenir les meilleures performances (voir tableau de compatibilité ) et utilise 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 Gist pour ce code.
Et voici le JSFiddle avec démonstration et test simple.
J'espère que ça va aider quelqu'un. À votre santé!
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 l’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 avec une chaîne de valeur vide.
L'utilisation de 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, Chrom, Firefox et IE 9, il est évident que dans la plupart des cas d'utilisation:
- (pour ... dans ...) 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 (ce qui n'est pas surprenant)
- Object.getOwnPropertyNames (obj) .length dure plus longtemps 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 détaillés des tests et le code de test à L'objet est-il vide?
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;
Mettre à jour
OR
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 vérifier si un objet JavaScript est vide, s'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)); // truefunction isEmpty(obj) {
for(var i in obj) { return false; }
return true;
}
jQuery a la 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/
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
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 simple code http://www.json.org/js.html .
Autre moyen simple (moyen le plus simple):
vous pouvez utiliser cette méthode sans utiliser l’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
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.
Je voudrais vérifier s'il y a au moins une clé. Cela suffirait pour me dire que ce n'est pas vide.
typeof obj !== "undefined" && Boolean(Object.keys(obj)[0])
Si jQuery et le navigateur Web ne sont pas disponibles, il existe également une fonction isEmpty dans underscore.js.
_.isEmpty({}) // returns true
De plus, le paramètre d'entrée n'est pas supposé être un objet. Pour une liste ou une chaîne ou indéfinie, la réponse correcte sera également activée.
Selon la spécification ES2017 sous Object.entries (), la vérification est simple en utilisant n'importe quel browser-- moderne
Object.entries({}).length === 0
La bonne réponse est:
const isEmptyObject = obj =>
Object.getOwnPropertyNames(obj).length === 0 &&
Object.getOwnPropertySymbols(obj).length === 0 &&
Object.getPrototypeOf(obj) === Object.prototype;
Ceci vérifie que:
- L'objet n'a pas de propriétés propres (indépendamment de l'énumération).
- L'objet n'a pas de symboles de propriété propres.
- Le prototype de l'objet est exactement
Object.prototype.
En d'autres termes, l'objet est identique à celui créé avec {}.
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)
résultats
{}
En plus de Thevs répondre:
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 à cette fin. Le code est propre et simple:
Faire un objet étendu:
a = Object.extended({})
Vérifiez sa taille:
a.size()
Une autre alternative consiste à utiliser is.js (14 Ko) par opposition à jquery (32 Ko), lodash (50 Ko) ou soulignement (16,4 Ko). is.js s'est avéré être la bibliothèque la plus rapide parmi les bibliothèques susmentionnées pouvant être utilisée 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. Par conséquent, si vous devez manipuler facilement le DOM, jquery peut toujours être un bon choix ou si vous avez besoin de plus que la simple vérification de type, puis lodash ou underscore pourrait être bon. En ce qui concerne is.js , voici la syntaxe:
var a = {};
is.empty(a); // true
is.empty({"hello": "world"}) // false
Comme pour les fonctions de soulignement et de lodash, _.isObject(), ceci ne s'applique pas exclusivement à 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 plus complète car elle renverra les propriétés énumérables et non énumérables telles que décrites 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 souhaitez pas importer de bibliothèque (ce qui est compréhensible) et que vous savez que vous ne faites que vérifier des objets (et non des tableaux ou des chaînes de caractères), la fonction suivante devrait alors répondre à vos besoins.
function isEmptyObject( obj ) {
return Object.getOwnPropertyNames(obj).length === 0;
}
Ceci est seulement un peu plus rapide que is.js, mais simplement parce que vous ne vérifiez pas si c'est un objet.
Sous le capot, toutes les méthodes de contrôle vides dans toutes les bibliothèques utilisent une logique de vérification des clés d'objet. C'est un moyen é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;
}
Ce qui a évolué dans ES5 , maintenant vous pouvez simplement vérifier la longueur des clés de l'objet, en utilisant la méthode Object.Keys qui prend votre objet comme paramètre:
if(Object.keys(obj).length > 0){
//do your work here
}
Ou si vous utilisez Lodash (vous devez être) alors.
_.isEmpty(obj) //==true or false
Je ne peux pas croire qu'après deux ans de programmation, il ne soit jamais clair que les objets vides et les tableaux ne sont pas du type falsey, la chose la plus étrange est qu'ils ne m'ont jamais surpris.
ceci retournera true si l'entrée est Falsey par défaut ou s'il s'agit d'un objet ou d'un tableau vide. l'inverse est la fonction trueish
http://codepen.io/synthet1c/pen/pjmoWL
function falsish( obj ){
if( (typeof obj === 'number' && obj > 0) || obj === true ){
return false;
}
return !!obj
? !Object.keys( obj ).length
: true;
}
function trueish( obj ){
return !falsish( obj );
}
falsish({}) //=> true
falsish({foo:'bar'}) //=> false
falsish([]) //=> true
falsish(['foo']) //=> false
falsish(false) //=> true
falsish(true) //=> false
// the rest are on codepen
ce code d'une ligne aide
var a = {}; //if empty returns false
(Object.getOwnPropertyNames != undefined ? Object.getOwnPropertyNames(a).length != 0 : (function(){for(var key in a) break; return (key != null) && (key != undefined);})()) //Returns False
var a = {b:2} //if not empty returns true
(Object.getOwnPropertyNames != undefined ? Object.getOwnPropertyNames(a).length != 0 : (function(){for(var key in a) break; return (key != null) && (key != undefined);})()) //Returns true
Object.getOwnPropertyNames est implémenté dans ECMA-5. la ligne ci-dessus fonctionne dans les navigateurs plus anciens avec une fonction de repli.
isEmpty = function(obj) {
if (obj == null) return true;
if (obj.constructor.name == "Array" || obj.constructor.name == "String") return obj.length === 0;
for (var key in obj) if (isEmpty(obj[key])) return true;
return false;
}
Cela vérifiera le vide de String, Array ou Object (Maps).
Utilisation:
var a = {"a":"xxx","b":[1],"c":{"c_a":""}}
isEmpty(a); // true, because a.c.c_a is empty.
isEmpty("I am a String"); //false
export function isObjectEmpty(obj) {
return (
Object.keys(obj).length === 0 &&
Object.getOwnPropertySymbols(obj).length === 0 &&
obj.constructor === Object
);
}
Cela inclut la recherche d’objets contenant propriétés du symbole.
Object.keys _ ne récupère pas les propriétés du symbole.
En attendant, nous pouvons avoir une fonction qui vérifie tous les "vides" comme null, undefined, '', '', {}, [] .
var isEmpty = function(data) {
if(typeof(data) === 'object'){
if(JSON.stringify(data) === '{}' || JSON.stringify(data) === '[]'){
return true;
}else if(!data){
return true;
}
return false;
}else if(typeof(data) === 'string'){
if(!data.trim()){
return true;
}
return false;
}else if(typeof(data) === 'undefined'){
return true;
}else{
return false;
}
}
Cas d'utilisation et résultats.
console.log(isEmpty()); // true
console.log(isEmpty(null)); // true
console.log(isEmpty('')); // true
console.log(isEmpty(' ')); // true
console.log(isEmpty(undefined)); // true
console.log(isEmpty({})); // true
console.log(isEmpty([])); // true
console.log(isEmpty(0)); // false
console.log(isEmpty('Hey')); // false
Essayez Destructuring
const a = {};
const { b } = a;
const emptryOrNot = (b) ? 'not Empty' : 'empty';
console.log(emptryOrNot)
C'est bizarre, je ne trouve pas ici de comparaison par valeurs (peut-être manquée parmi tant de solutions) ... Je voudrais couvrir le cas où l'objet est considéré comme vide si toutes ses valeurs ne sont pas définies:
const isObjectEmpty = ( obj ) => Object.values( obj ).every( val => typeof val === "undefined" );
isObjectEmpty({ foo: undefined, bar: undefined }): // true
isObjectEmpty({ foo: false, bar: null }): // false
Ainsi, nous pouvons étendre, disons, objet options uniquement lorsque des sous-options sont fournies.
function onSubmit({ fullPage, width, height }) {
const baseOptions = { fullPage },
clip = { width, height },
options = isObjectEmpty( clip ) ? baseOptions : { ...baseOptions, clip };
//...
}
Pure Vanilla Javascript et compatibilité totale avec les versions antérieures
function isObjectDefined (Obj) {
if (Obj === null || typeof Obj !== 'object' ||
Object.prototype.toString.call(Obj) === '[object Array]') {
return false
} else {
for (var prop in Obj) {
if (Obj.hasOwnProperty(prop)) {
return true
}
}
return JSON.stringify(Obj) !== JSON.stringify({})
}
}
console.log(isObjectDefined()) // false
console.log(isObjectDefined('')) // false
console.log(isObjectDefined(1)) // false
console.log(isObjectDefined('string')) // false
console.log(isObjectDefined(NaN)) // false
console.log(isObjectDefined(null)) // false
console.log(isObjectDefined({})) // false
console.log(isObjectDefined([])) // false
console.log(isObjectDefined({a: ''})) // truePour accepter vraimentSEULEMENT{}, la meilleure façon de le faire en Javascript avec Lodash est:
_.isEmpty(value) && _.isPlainObject(value)
Vous pouvez définir votre propre prototype d'objet, juste avant son utilisation ou au début de votre code.
La définition devrait ressembler à ceci:
Object.prototype.hasOwnProperties = function()
{
for (var k in this)
{
if ( this.hasOwnProperty(k) )
{
return true;
}
}
return false;
}Voici un exemple d'utilisation:
var a = {};
while ( a.status !== "finished" )
{
if ( status === "processing" )
{
a.status = "finished";
}
if ( status === "starting" )
{
a.status = "processing";
}
if ( !a.hasOwnProperties() )
{
a.status = "starting";
}
}Prendre plaisir! :-)
Je renvoyais une réponse JSON vide pour un appel AJAX et dans IE8, jQuery.isEmptyObject () ne se validait pas correctement. J'ai ajouté un chèque supplémentaire qui semble bien le comprendre.
.done(function(data)
{
// Parse json response object
var response = jQuery.parseJSON(data);
// In IE 8 isEmptyObject doesn't catch the empty response, so adding additional undefined check
if(jQuery.isEmptyObject(response) || response.length === 0)
{
//empty
}
else
{
//not empty
}
});
A partir de jQuery 1.4, la méthode isEmptyObject() vérifie les propriétés de l'objet et les propriétés héritées des prototypes (en ce sens qu'elle n'utilise pas hasOwnProperty). L'argument doit toujours être un objet JavaScript simple, car les autres types d'objet (éléments DOM, chaînes/nombres primitifs, objets hôte) peuvent ne pas donner des résultats cohérents sur tous les navigateurs. Pour déterminer si un objet est un objet JavaScript simple, utilisez $.isPlainObject().
jQuery.isPlainObject({}) // true
jQuery.isPlainObject( "test" ) // false
C’est ce que j’ai proposé de dire s’il existe des valeurs non nulles dans l’objet.
function isEmpty(obj: Object): Boolean {
for (const prop in obj) {
if (obj.hasOwnProperty(prop)) {
if (obj[prop] instanceof Object) {
const rtn = this.isEmpty(obj[prop]);
if (rtn === false) {
return false;
}
} else if (obj[prop] || obj[prop] === false) {
return false;
}
}
}
return true;
}