Comment vérifier si l'objet a des propriétés en JavaScript?

En supposant que je déclare

var ad = {}; 

Comment puis-je vérifier si cet objet contiendra des propriétés définies par l'utilisateur?

Vous pouvez parcourir les propriétés de votre objet comme suit:

for(var prop in ad) {
    if (ad.hasOwnProperty(prop)) {
        // handle prop as required
    }
}

Il est important d'utiliser la hasOwnProperty()méthode pour déterminer si l'objet a la propriété spécifiée en tant que propriété directe et non héritée de la chaîne de prototypes de l'objet.

Éditer

À partir des commentaires: vous pouvez mettre ce code dans une fonction et le faire renvoyer false dès qu'il atteint la partie où se trouve le commentaire

Test de performance

Test Of Object.Keys vs For..In Lors du test de toutes les propriétés

Vous pouvez utiliser la Object.keysméthode intégrée pour obtenir une liste de clés sur un objet et tester sa longueur.

var x = {};
// some code where value of x changes and than you want to check whether it is null or some object with values

if(Object.keys(x).length > 0){
 // Your code here if x has some properties  
}

Qu'en est-il de créer une fonction simple?

function isEmptyObject(obj) {
  for(var prop in obj) {
    if (Object.prototype.hasOwnProperty.call(obj, prop)) {
      return false;
    }
  }
  return true;
}

isEmptyObject({}); // true
isEmptyObject({foo:'bar'});  // false

L' hasOwnPropertyappel de méthode directement sur le Object.prototypen'est qu'ajouter un peu plus de sécurité , imaginez ce qui suit en utilisant un obj.hasOwnProperty(...)appel normal :

isEmptyObject({hasOwnProperty:'boom'});  // false

Remarque: _{(pour le futur)} La méthode ci-dessus repose sur l' for...ininstruction, et cette instruction n'itère que sur les propriétés énumérables , dans la norme ECMAScript la plus largement implémentée actuellement (3e édition), le programmeur n'a aucun moyen de créer des propriétés non énumérables .

Cependant, cela a changé maintenant avec ECMAScript 5e édition , et nous sommes en mesure de créer des propriétés non énumérables, non inscriptibles ou non supprimables, de sorte que la méthode ci-dessus peut échouer , par exemple:

var obj = {};
Object.defineProperty(obj, 'test', { value: 'testVal', 
  enumerable: false,
  writable: true,
  configurable: true
});
isEmptyObject(obj); // true, wrong!!
obj.hasOwnProperty('test'); // true, the property exist!!

Une solution ECMAScript 5 à ce problème serait:

function isEmptyObject(obj) {
  return Object.getOwnPropertyNames(obj).length === 0;
}

La Object.getOwnPropertyNamesméthode retourne un Arraycontenant les noms de toutes les propriétés propres d'un objet, énumérables ou non , cette méthode est maintenant implémentée par les fournisseurs de navigateurs, elle est déjà sur la version bêta de Chrome 5 et le dernier WebKit Nightly Builds.

Object.defineProperty est également disponible sur ces navigateurs et sur les dernières versions de Firefox 3.7 Alpha.

Avec jQuery, vous pouvez utiliser:

$.isEmptyObject(obj); // Returns: Boolean

Depuis jQuery 1.4, cette méthode vérifie à la fois les propriétés de l'objet lui-même et les propriétés héritées des prototypes (en ce sens qu'elle n'utilise pas hasOwnProperty).

Avec ECMAScript 5th Edition dans les navigateurs modernes (IE9 +, FF4 +, Chrome5 +, Opera12 +, Safari5 +), vous pouvez utiliser la méthode Object.keys intégrée :

var obj = { blah: 1 };
var isEmpty = !Object.keys(obj).length;

Ou tout vieux JavaScript:

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

Les navigateurs les plus récents (et node.js) prennent en charge Object.keys () qui renvoie un tableau avec toutes les clés de votre objet littéral afin que vous puissiez faire ce qui suit:

var ad = {}; 
Object.keys(ad).length;//this will be 0 in this case

Prise en charge du navigateur: Firefox 4, Chrome 5, Internet Explorer 9, Opera 12, Safari 5

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys

Si vous utilisez underscore.js, vous pouvez utiliser la fonction _.isEmpty :

var obj = {};
var emptyObject = _.isEmpty(obj);

Si vous êtes prêt à utiliser lodash , vous pouvez utiliser la someméthode.

_.some(obj) // returns true or false

Voir ce petit exemple jsbin

for (var hasProperties in ad) break;
if (hasProperties)
    ... // ad has properties

Si vous devez être prudent et vérifier les prototypes d'objets (ceux-ci sont ajoutés par certaines bibliothèques et pas là par défaut):

var hasProperties = false;
for (var x in ad) {
    if (ad.hasOwnProperty(x)) {
        hasProperties = true;
        break;
    }
}
if (hasProperties)
    ... // ad has properties

for(var memberName in ad)
{
  //Member Name: memberName
  //Member Value: ad[memberName]
}

Membre signifie propriété de membre, variable de membre, comme vous voulez l'appeler> _>

Le code ci-dessus renverra TOUT, y compris toString ... Si vous voulez seulement voir si le prototype de l'objet a été étendu:

var dummyObj = {};  
for(var memberName in ad)
{
  if(typeof(dummyObj[memberName]) == typeof(ad[memberName])) continue; //note A
  //Member Name: memberName
  //Member Value: ad[memberName]

}

Note A: Nous vérifions si le membre de l'objet factice a le même type que le membre de notre objet de test. S'il s'agit d'une extension, le type de membre dummyobject doit être "indéfini"

var hasAnyProps = false; for (var key in obj) { hasAnyProps = true; break; }
// as of this line hasAnyProps will show Boolean whether or not any iterable props exist

Simple, fonctionne dans tous les navigateurs, et même s'il s'agit techniquement d'une boucle pour toutes les clés de l'objet, il ne les parcourt PAS toutes ... soit il y a 0 et la boucle ne s'exécute pas, soit il y en a et il se brise après le premier un (parce que tout ce que nous vérifions, c'est s'il y en a un ... alors pourquoi continuer?)

Réponse très tardive, mais c'est ainsi que vous pourriez le gérer avec des prototypes.

Array.prototype.Any = function(func) {
    return this.some(func || function(x) { return x });
}

Object.prototype.IsAny = function() {
    return Object.keys(this).Any();
}

Lorsque vous êtes sûr que l'objet est défini par l'utilisateur, le moyen le plus simple de déterminer si UDO est vide serait le code suivant:

isEmpty=
/*b.b Troy III p.a.e*/
function(x,p){for(p in x)return!1;return!0};

Même si cette méthode est (par nature) déductive, - c'est la plus rapide et la plus rapide possible.

a={};
isEmpty(a) >> true

a.b=1
isEmpty(a) >> false 

ps:! ne l'utilisez pas sur des objets définis par le navigateur.

Réponse tardive, mais certains frameworks traitent les objets comme des énumérables. Par conséquent, bob.js peut le faire comme ceci:

var objToTest = {};
var propertyCount = bob.collections.extend(objToTest).count();

Vous pouvez utiliser les éléments suivants:

Double coup !! recherche de propriété

var a = !![]; // true
var a = !!null; // false

hasOwnProperty C'est quelque chose que j'utilisais:

var myObject = {
  name: 'John',
  address: null
};
if (myObject.hasOwnProperty('address')) { // true
  // do something if it exists.
}

Cependant, JavaScript a décidé de ne pas protéger le nom de la méthode, afin qu'elle puisse être falsifiée.

var myObject = {
  hasOwnProperty: 'I will populate it myself!'
};

prop dans myObject

var myObject = {
  name: 'John',
  address: null,
  developer: false
};
'developer' in myObject; // true, remember it's looking for exists, not value.

Type de

if (typeof myObject.name !== 'undefined') {
  // do something
}

Cependant, il ne vérifie pas la valeur null.

Je pense que c'est la meilleure façon.

en opérateur

var myObject = {
  name: 'John',
  address: null
};

if('name' in myObject) {
  console.log("Name exists in myObject");
}else{
  console.log("Name does not exist in myObject");
}

résultat:

Le nom existe dans myObject

Voici un lien qui donne plus de détails sur l'opérateur in: Déterminer si une propriété d'objet existe

Fonction ES6

/**
 * Returns true if an object is empty.
 * @param  {*} obj the object to test
 * @return {boolean} returns true if object is empty, otherwise returns false
 */
const pureObjectIsEmpty = obj => obj && obj.constructor === Object && Object.keys(obj).length === 0

Exemples:

let obj = "this is an object with String constructor"
console.log(pureObjectIsEmpty(obj)) // empty? true

obj = {}
console.log(pureObjectIsEmpty(obj)) // empty? true

obj = []
console.log(pureObjectIsEmpty(obj)) // empty? true

obj = [{prop:"value"}]
console.log(pureObjectIsEmpty(obj)) // empty? true

obj = {prop:"value"}
console.log(pureObjectIsEmpty(obj)) // empty? false

Que dis-tu de ça?

var obj = {},
var isEmpty = !obj;
var hasContent = !!obj