Comment puis-je vérifier si un objet possède une propriété en JavaScript?

avec Underscore.js ou ( encore mieux ) lodash :

_.has(x, 'key');

qui appelle Object.prototype.hasOwnProperty , mais (a) est plus court à taper, et (B) utilise "une référence sûre à hasOwnProperty "(i.e. il fonctionne même si hasOwnProperty est écrasée).

en particulier, lodash définit _.has comme:

   function has(object, key) {
      return object ? hasOwnProperty.call(object, key) : false;
   }
   // hasOwnProperty = Object.prototype.hasOwnProperty

Note : ce qui suit est aujourd'hui largement obsolète grâce au mode strict, et hasOwnProperty . La solution correcte est d'utiliser le mode strict et de vérifier la présence d'une propriété en utilisant obj.hasOwnProperty . Cette réponse précède ces deux choses, au moins aussi largement mis en œuvre (oui, il est que vieux). Prendre ce qui suit comme une note historique.

gardez à l'esprit que undefined est (malheureusement) pas un mot réservé en JavaScript si vous n'utilisez pas le mode strict. Par conséquent, quelqu'un (quelqu'un d'autre, évidemment) pourrait avoir la grande idée de le redéfinir, briser votre code.

une méthode plus robuste est donc la suivante:

if (typeof(x.attribute) !== 'undefined')

de l'autre côté, cette méthode est beaucoup plus verbeuse et aussi plus lente. :- /

une solution de rechange courante consiste à s'assurer que undefined est actuellement Non défini, p.ex. en mettant le code dans une fonction qui accepte un paramètre supplémentaire, appelé undefined , qui n'est pas passé une valeur. Pour vous assurer qu'il n'est pas passé une valeur, vous pouvez simplement l'appeler vous-même immédiatement, par exemple:

(function (undefined) {
    … your code …
    if (x.attribute !== undefined)
        … mode code …
})();

à quel sujet?

var x = {'key': 1};

if ('key' in x) {
    console.log('has');
}

if (x.key !== undefined)

Armin Ronacher semble avoir déjà battu à elle , mais:

Object.prototype.hasOwnProperty = function(property) {
    return this[property] !== undefined;
};

x = {'key': 1};

if (x.hasOwnProperty('key')) {
    alert('have key!');
}

if (!x.hasOwnProperty('bar')) {
    alert('no bar!');
}

plus sûr, mais plus lente de la solution, comme l'a souligné par Konrad Rudolph et Armin Ronacher serait:

Object.prototype.hasOwnProperty = function(property) {
    return typeof this[property] !== 'undefined';
};

vous pouvez utiliser l'opérateur in pour vérifier si la propriété existe sur un objet:

x = {'key': 1};
alert("key" in x);

vous pouvez également boucler toutes les propriétés de l'objet en utilisant une boucle for - in , puis vérifier la propriété spécifique:

for (prop in x) {
    if (prop == "key") {
        //Do something
    }
}

vous devez considérer si cette propriété d'objet est énumérable ou non, parce que les propriétés non-énumérables ne seront pas présentées dans une boucle for-in . En outre, si la propriété énumérable est shadowing une propriété non-énumérable du prototype, il ne se présentera pas dans Internet Explorer 8 et plus tôt.

si vous voulez une liste de toutes les propriétés d'une instance, qu'elle soit énumérable ou non, vous pouvez utiliser

Object.getOwnPropertyNames(x);

renvoie un tableau des noms de toutes les propriétés qui existent sur un objet.

Enfin, vous pouvez utiliser l'opérateur typeof de vérifier directement le type de données de l'objet propriété:

if (typeof x.key == "undefined") {
    alert("undefined");
}

si la propriété n'existe pas sur l'objet, elle retournera la chaîne non définie. Sinon, il retournera le type de propriété approprié. Cependant, notez que ce n'est pas toujours une façon valide de vérifier si un objet a une propriété ou non, parce que vous pourriez avoir une propriété qui est définie à non défini, dans ce cas, en utilisant typeof x.key retournerait toujours true (même si la clé est toujours dans l'objet).

mise à jour: vous pouvez vérifiez si une propriété existe en comparant à la propriété javascript non définie

if (x.key === undefined) {
    alert("undefined");
}

cela devrait fonctionner à moins que la clé ne soit spécifiquement définie à undefined sur l'objet x

coupons un peu la confusion ici. Tout d'abord, simplifions en supposant que hasOwnProperty existe déjà; c'est le cas de la grande majorité des navigateurs actuels utilisés.

hasOwnProperty retourne true si le nom d'attribut qui lui est passé a été ajouté à l'objet. Elle est entièrement indépendante de la valeur réelle qui lui est attribuée, qui peut être exactement undefined .

D'où:

var o = {}
o.x = undefined

var a = o.hasOwnProperty('x')  // a is true
var b = o.x === undefined // b is also true

cependant:

var o = {}

var a = o.hasOwnProperty('x')  // a is now false
var b = o.x === undefined // b is still true

le problème est que se passe-t-il lorsqu'un objet de la chaîne prototype possède un attribut dont la valeur n'est pas définie? hasOwnProperty sera faux pour elle, et ainsi sera !== undefined . Pourtant, for..in va encore l'énumérer dans l'énumération.

la ligne de fond est qu'il n'y a aucun moyen de traverser le navigateur (puisque Internet Explorer n'expose pas __prototype__ ) pour déterminer qu'un l'identificateur n'a pas été fixé à un objet ou à quoi que ce soit de sa chaîne prototype.

si vous cherchez une propriété, alors"non". Vous voulez:

if ('prop' in obj) { }

en général, vous ne devriez pas se soucier si la propriété vient ou non du prototype ou de l'objet.

cependant, parce que vous avez utilisé 'key' dans votre exemple de code, il semble que vous traitiez l'objet comme un hachage, auquel cas votre réponse aurait du sens. Tous les hash clés seraient propriétés de l'objet, et vous évitez les propriétés supplémentaires contribué par le prototype.

la réponse de John Resig était très complète, mais je pensais qu'elle n'était pas claire. Surtout avec quand utiliser "'prop' dans obj".

Oui, ça l'est :) je pense que vous pouvez le faire aussi Object.prototype.hasOwnProperty.call(x, 'key') , qui devrait également fonctionner si x a une propriété appelée hasOwnProperty :)

mais que des essais pour ses propres propriétés. Si vous voulez vérifier si il a une propriété qui peut également être inhered vous pouvez utiliser typeof x.foo != 'undefined' .

if (typeof x.key != "undefined") {

}

parce que

if (x.key)

échoue si x.key se résout en false (par exemple, x.key = "" ).

vous pouvez également utiliser le ES6 Reflect objet :

x = {'key': 1};
Reflect.has( x, 'key'); // returns true

la Documentation sur MDN pour Reflect.has peut être trouvée ici .

la méthode statique Reflect.has() fonctionne comme la dans l'opérateur comme une fonction.

pour tester l'utilisation d'objets simples: if (obj[x] !== undefined)

si vous ne savez pas quel type d'objet il utilise: if (obj.hasOwnProperty(x))

toutes les autres options sont plus lentes..

Détails

l'évaluation de la Performance de 100.000.000 cycles sous Nodejs pour les 5 options proposées par les autres ici:

function hasKey1(k,o) { return (x in obj); }
function hasKey2(k,o) { return (obj[x]); }
function hasKey3(k,o) { return (obj[x] !== undefined); }
function hasKey4(k,o) { return (typeof(obj[x]) !== 'undefined'); }
function hasKey5(k,o) { return (obj.hasOwnProperty(x)); }

l'évaluation nous dit qu'à moins que nous voulions spécifiquement vérifier la chaîne prototype de l'objet ainsi que l'objet lui-même, nous ne devrions pas utiliser la forme commune: if (X in Obj)... il est entre 2 à 6 fois plus lent selon le cas d'utilisation

hasKey1 execution time: 4s 510.427785ms
hasKey2 execution time: 0s 904.374806ms
hasKey3 execution time: 0s 760.336193ms
hasKey4 execution time: 0s 935.19901ms
hasKey5 execution time: 2s 148.189608ms

en bref, si votre Obj n'est pas nécessairement un objet simple et que vous souhaitez éviter de vérifier la chaîne prototype de l'objet et de vous assurer que x est la propriété directe de L'Obj, utilisez " si (obj.hasOwnProperty (x))...'.

dans le cas contraire, lorsqu'on utilise un objet simple et qu'on ne s'inquiète pas de la chaîne prototype de l'objet, utiliser if (typeof(obj[x]) !== 'undefined')... est le moyen le plus sûr et le plus rapide.

si vous utilisez un objet simple comme table de hachage et ne faites jamais rien de pervers, j'utiliserais if (obj[x])... car je le trouve beaucoup plus lisible.

amusez-vous bien.

OK, il semble que j'ai eu la bonne réponse sauf si vous ne voulez pas de propriétés héritées:

if (x.hasOwnProperty('key'))

Voici d'autres options pour inclure les propriétés héritées:

if (x.key) // Quick and dirty, but it does the same thing as below.

if (x.key !== undefined)

hasOwnProperty "peut être utilisé pour déterminer si un objet a la propriété spécifiée comme une propriété directe de cet objet; contrairement à l'opérateur in , cette méthode ne vérifie pas la chaîne prototype de l'objet."

donc très probablement, pour ce qui semble par votre question, vous ne voulez pas utiliser hasOwnProperty, qui détermine si la propriété existe comme attaché directement à l'objet lui-même ,.

Si vous souhaitez déterminer si la propriété existe dans la chaîne de prototype vous souhaitez utiliser, comme:

if( prop in object ){ // do something }

j'espère que cela aidera.

une autre façon relativement simple est d'utiliser Object.keys . Cela renvoie un array qui signifie que vous obtenez toutes les fonctionnalités d'un tableau.

var noInfo = {};
var info = {something: 'data'};

Object.keys(noInfo).length //returns 0 or false
Object.keys(info).length //returns 1 or true

bien que nous soyons dans un monde avec un grand soutien de navigateur. Parce que cette question Est si ancienne que j'ai pensé ajouter ceci:: Il peut être utilisé sans danger à partir de JS v1.8.5

avec un risque de rétrogradation massive, voici une autre option pour un cas spécifique. :)

Si vous voulez tester par un membre sur un objet et que vous voulez savoir s'il a été réglé sur autre chose que:

• "
• false
• null
• Non défini
• 0 ...

alors vous pouvez utiliser:

var foo = {};
foo.bar = "Yes, this is a proper value!";
if (!!foo.bar) {
        // member is set, do something
}

ECMA Script 6 solution with reflect. Créer l'emballage comme:

/**
Gets an argument from array or object.
The possible outcome:
- If the key exists the value is returned.
- If no key exists the default value is returned.
- If no default value is specified an empty string is returned.
@param obj    The object or array to be searched.
@param key    The name of the property or key.
@param defVal Optional default version of the command-line parameter [default ""]
@return The default value in case of an error else the found parameter.
*/
function getSafeReflectArg( obj, key, defVal) {
   "use strict";
   var retVal = (typeof defVal === 'undefined' ? "" : defVal);
   if ( Reflect.has( obj, key) ) {
       return Reflect.get( obj, key);
   }
   return retVal;
}  // getSafeReflectArg

Il y a la méthode "hasOwnProperty" existe sur l'objet, mais ce n'est pas recommandé d'appeler cette méthode directement parce que peut-être parfois l'objet est null ou certains biens existent sur l'objet comme: { hasOwnProperty: false }

Donc le meilleur moyen serait:

// good
var obj = {"bar": "here bar desc"}
console.log(Object.prototype.hasOwnProperty.call(obj, "bar"));

// best
const has = Object.prototype.hasOwnProperty; // cache the lookup once, in module scope.
console.log(has.call(obj, "bar"));

Ne faites pas cela object.hasOwnProperty(key)) , son vraiment mauvaise, car ces méthodes peuvent être occultées par les propriétés sur l'objet en question - envisager { hasOwnProperty: false } - ou l'objet peut être un objet null (Object.create(null)) .

La meilleure façon est de faire Object.prototype.hasOwnProperty.call(object, key) ou:

const has = Object.prototype.hasOwnProperty; // cache the lookup once, in module scope.
/* or */
import has from 'has'; // https://www.npmjs.com/package/has
// ...
console.log(has.call(object, key));

Vous devez utiliser la méthode object.hasOwnProperty(property) . Il retourne true si l'objet a la propriété et false si l'objet n'a pas la propriété.

si la clé que vous vérifiez est stockée dans une variable , vous pouvez le vérifier comme ceci:

x = {'key': 1};
y = 'key';
x[y];

Pourquoi cours-compliquer quand on peut faire:

var isProperty =  (objectname.keyname || "") ? true : false;

Simple et clair pour la plupart des cas...

j'ai utilisé ceci. ce qui m'a beaucoup aidé si vous avez un objet à l'intérieur de l'objet

if(typeof(obj["key"])=="string"){
    alert("property");
}