web-dev-qa-db-fra.com

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?

2167
falmp

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

Souligner :

_.isEmpty({}); // true

Hoek

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

ExtJS

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

AngularJS (version 1)

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

Ramda

R.isEmpty({}); // true
3686
Adam Zerner

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

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

547
Erik Töyrä

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
214
dhruvio

Vous pouvez utiliser Underscore.js .

_.isEmpty({}); // true
191
Baggz
if(Object.getOwnPropertyNames(obj).length === 0){
  //is empty
}

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

107
es cologne

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

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

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;
}
54
Jonathan Petitcolas

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

47
Anish Nair

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

28
download

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

21
Slava Fomin II

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

if (Object.keys(a).length > 0) {
    // not empty
}
20
Ashutosh Ranjan
  1. 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.

  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 avec une chaîne de valeur vide.

19
Thevs

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?

17
davidhadas

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

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

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));    // true

11
GibboK
function isEmpty(obj) {
  for(var i in obj) { return false; }
  return true;
}
10
ikettu

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/

10
Anton Danilchenko

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
9
DiegoAraujo


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
9
iman

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.

8
NiKo

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])
8
Tudor Morar

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.

8
jichi

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

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

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

5
Jesse

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

 {} 
5
Ekim

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

4
starikovs

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()
4
mikemaccana

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.

3
cwadding

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
2
ahmadalibaloch

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
2
synthet1c

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.

JSFiddler

2
Nirus
    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
2
Rahul Malhotra
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.

1
Jplus2

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
1
Imran

Essayez Destructuring

const a = {};
const { b } = a;
const emptryOrNot = (b) ? 'not Empty' : 'empty';
console.log(emptryOrNot)
1
Igor Kokotko

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 };
//...
}
0
Dmitry Sheiko

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: ''})) // true

Pour accepter vraimentSEULEMENT{}, la meilleure façon de le faire en Javascript avec Lodash est:

_.isEmpty(value) && _.isPlainObject(value)
0
Anthony D'Amato

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! :-)

0
Slavik Meltser

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
    }
});
0
CatTest

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

Jquery api

0
chandu

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