Comment vérifier si l'objet possède des propriétés JavaScript?

Vous pouvez modifier 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 méthode hasOwnProperty() pour déterminer si l'objet a la propriété spécifiée en tant que propriété directe et n'est pas hérité de la chaîne prototype de l'objet.

modifier

À partir des commentaires: Vous pouvez mettre ce code dans une fonction, et le rendre retourne faux dès qu'il atteint la partie où il y a le commentaire

Qu'en est-il de faire 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 

La méthode hasOwnProperty appelle directement sur Object.prototype est seulement pour ajouter un peu plus de sécurité , imaginez ce qui suit en utilisant un obj.hasOwnProperty(...) normal obj.hasOwnProperty(...) :

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

Remarque: _{(pour l'avenir)} La méthode ci-dessus repose sur l'instruction for...in , et cette déclaration ne concerne que les propriétés énumérables , dans la norme ECMAScript la plus largement mise en œuvre (3ème édition), le programmeur n'a aucun moyen de Créez des propriétés non énumérables.

Cependant, cela a changé maintenant avec ECMAScript 5ème édition , et nous sommes en mesure de créer des propriétés non énumérées, non inscrites 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 méthode Object.getOwnPropertyNames renvoie une Array contenant les noms de toutes les propriétés propres à un objet, énumérant ou non , cette méthode est actuellement mise en œuvre par les fournisseurs de navigateurs, elle est déjà sur Chrome 5 Beta et les dernières WebKit Nightly Builds.

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

Avec jQuery, vous pouvez utiliser:

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

À partir de jQuery 1.4, cette méthode vérifie les deux propriétés sur l'objet lui-même et les propriétés héritées des prototypes (dans la mesure où il n'utilise pas hasOwnProperty).

Avec ECMAScript 5ème édition 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 un ancien JavaScript:

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

Vous pouvez utiliser la méthode construite dans Object.keys 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 } 

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 littéral d'objet afin que vous puissiez faire ce qui suit:

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

Support 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 méthode.

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

Voir ce petit exemple jsbin

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

Le membre signifie Propriété membre, variable membre, quel que soit votre désir d'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 fictif a le même type que le membre de l'objet test. Si c'est une extension, le type de membre de Dummyobject doit être "indéfini"

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

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

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

Il existe deux façons de le faire:

1. PropName in obj
2. Obj.hasOwnProperty (propName)

Cependant, faites attention: il existe une très grande différence entre les deux:

Le premier renverra true si obj a une propriété nommée propName (obj.propName), mais si elle n'en trouve pas, elle continuera à chercher un nom dans l'arbre prototype . S'il y trouve un, l'expression retournera true sinon elle renverra false .

Le deuxième exemple vérifiera uniquement l'objet lui-même sans vérifier son (ses) prototype (s). C'est comme une itération d'un tableau.

Exemple:

 function Obj(){ this.a = undefined; this.b = null; this.c = false; } Obj.prototype = { d: true, e: true }; var obj = new Obj(); 

Et pour le tester:

 "a" in obj // true "e" in obj // true obj.hasOwnProperty("a") // true obj.hasOwnProperty("e") // false 

Lorsque l'objet est défini par l'utilisateur, la manière la plus simple de déterminer si UDO est vide est le code suivant:

 isEmpty= /*bb Troy III pae*/ function(x,p){for(p in x)return!1;return!0}; 

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

 a={}; isEmpty(a) >> true ab=1 isEmpty(a) >> false 

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

Réponse tardive, mais certains frameworks gèrent les objets comme énumérables. Par conséquent, Bob.js peut le faire comme ceci:

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

 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 touches de l'objet, il ne boucle pas tous … Il n'y a pas de 0 et la boucle ne fonctionne pas ou il y en a une et elle se casse après la première Un (car tout ce que nous vérifions est s'il y a QUELQUE …) pourquoi pourquoi continuer?

Vous pouvez utiliser ce qui suit:

Double Bang! Recherche de propriété

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

HasOwnProperty C'est quelque chose que j'ai utilisé:

 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, de sorte qu'il pourrait être falsifié.

 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 nulle.

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 se déploie plus en détail sur l'opérateur: Déterminer si une propriété d'objet existe

J'ai écrit 2 composants open source qui peuvent être utiles pour cela. Si vous souhaitez vérifier si l'objet possède ou non un certain porperty spécifié par l'utilisateur, vous pouvez utiliser ce composant object-hasOwnPropert . Exemples:

 hasOwnProperty({foo: 'bar'}, 'foo') // => true hasOwnProperty({foo: 'bar'}, 'bar') // => false 

Pour vérifier si l'objet possède des propriétés (c'est-à-dire vide), vous pouvez utiliser ce composant objet-vide .

Exemples:

 empty([]) // => true empty({}) // => true empty(1) // => false empty('') // => false empty('foo') // => true 

J'espère que cela t'aides.