javascript tester si une variable est vide




Comment tester un objet JavaScript vide? (20)

Après une requête AJAX, mon application peut parfois retourner un objet vide, tel que:

var a = {};

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


  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.


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

    Beware!! obj is NOT empty!

    obj = {  f:function(){}  }

    JSON.stringify( obj )

    returns

    {}

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


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 les fonctionnalités developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… de ECMAScript 5 (ES5) pour obtenir les meilleures performances (voir tableau de compatibilité ) et les developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… de developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… les plus compatibles 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 cela aidera quelqu'un. À votre santé!


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

OU

vous pouvez utiliser l'implémentation jQuery de isEmptyObject

function isEmptyObject ( obj ) {
        var name;
        for ( name in obj ) {
            return false;
        }
        return true;
    }

Je voudrais vérifier s'il y a au moins une clé. Cela suffirait à me dire que ce n'est pas vide.

Boolean(Object.keys(obj)[0])

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


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


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.


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


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

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

Une autre alternative consiste à utiliser is.js (14 ko) par opposition à jquery (32 ko), lodash (50 ko) ou underscore (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 avez besoin de manipuler facilement le DOM, jquery peut toujours être un bon choix ou si vous avez besoin de plus que de la simple vérification de type, lodash ou le underscore peuvent être lodash . En ce qui concerne is.js , voici la syntaxe:

var a = {};
is.empty(a); // true
is.empty({"hello": "world"}) // false

Comme _.isObject() underscore et de _.isObject() , ce n'est pas exclusivement pour les objects mais s'applique également aux arrays et aux strings .

Sous le capot, cette bibliothèque utilise Object.getOwnPropertyNames qui est similaire à Object.keys mais Object.getOwnPropertyNames est un Object.getOwnPropertyNames plus complet car il renverra les propriétés énumérées et non énumérables.

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), 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 bien que vous ne vérifiiez pas si c'est un objet.


Une autre façon simple et pure de JS :)

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


Vieille question, mais juste eu le problème. Inclure JQuery n'est pas vraiment une bonne idée si votre seul objectif 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 suivante:

function isEmptyObject(obj) {
    var name;
    for (name in obj) {
        if (obj.hasOwnProperty(name)) {
            return false;
        }
    }
    return true;
}

Vous pouvez utiliser Underscore .

_.isEmpty({}); // true

jQuery a une fonction spéciale isEmptyObject() pour ce cas:

jQuery.isEmptyObject({}) // true
jQuery.isEmptyObject({ foo: "bar" }) // false

Plus d'informations sur jQuery


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


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

La classe JSON et ses fonctions ( analyse et stringify ) sont très utiles, mais quelques problèmes avec IE7 ont été résolus avec le code simple 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

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




json