Question Comment vérifier si un objet a une propriété dans JavaScript?


Comment vérifier si un objet a une propriété dans JavaScript?

Considérer:

x = {'key': 1};
if ( x.hasOwnProperty('key') ) {
    //Do this
}

Est-ce la meilleure façon de le faire?


1180
2017-09-25 19:27


origine


Réponses:


Je suis vraiment confus par les réponses qui ont été données - la plupart d'entre elles sont carrément incorrectes. Bien sûr, vous pouvez avoir des propriétés d'objet qui ont des valeurs non définies, nulles ou fausses. Donc, simplement réduire le contrôle de la propriété à typeof this[property] ou, pire encore, x.key vous donnera des résultats complètement trompeurs.

Cela dépend de ce que vous cherchez. Si vous voulez savoir si un objet contient physiquement une propriété (et qu'il ne vient pas de quelque part sur la chaîne du prototype) alors object.hasOwnProperty est le chemin à parcourir. Tous les navigateurs modernes le supportent. (Il manquait dans les anciennes versions de Safari - 2.0.1 et plus - mais ces versions du navigateur sont rarement utilisées.)

Si ce que vous cherchez est si un objet a une propriété qui est itérable (quand vous itérez sur les propriétés de l'objet, il apparaîtra) alors faites: prop in object vous donnera l'effet désiré.

Depuis l'utilisation hasOwnProperty est probablement ce que vous voulez, et étant donné que vous pouvez vouloir une méthode de repli, je vous présente la solution suivante:

var obj = {
    a: undefined,
    b: null,
    c: false
};

// a, b, c all found
for ( var prop in obj ) {
    document.writeln( "Object1: " + prop );
}

function Class(){
    this.a = undefined;
    this.b = null;
    this.c = false;
}

Class.prototype = {
    a: undefined,
    b: true,
    c: true,
    d: true,
    e: true
};

var obj2 = new Class();

// a, b, c, d, e found
for ( var prop in obj2 ) {
    document.writeln( "Object2: " + prop );
}

function hasOwnProperty(obj, prop) {
    var proto = obj.__proto__ || obj.constructor.prototype;
    return (prop in obj) &&
        (!(prop in proto) || proto[prop] !== obj[prop]);
}

if ( Object.prototype.hasOwnProperty ) {
    var hasOwnProperty = function(obj, prop) {
        return obj.hasOwnProperty(prop);
    }
}

// a, b, c found in modern browsers
// b, c found in Safari 2.0.1 and older
for ( var prop in obj2 ) {
    if ( hasOwnProperty(obj2, prop) ) {
        document.writeln( "Object2 w/ hasOwn: " + prop );
    }
}

Ce qui précède est un travail, navigateur croisé, solution à hasOwnProperty, avec une mise en garde: Il est impossible de distinguer entre les cas où une propriété identique est sur le prototype et sur l'instance - il suppose simplement qu'il provient du prototype. Vous pouvez le déplacer pour qu'il soit plus indulgent ou plus strict, en fonction de votre situation, mais à tout le moins cela devrait être plus utile.


1202
2017-09-25 21:52



Avec Underscore.js ou (encore mieux) lodash:

_.has(x, 'key');

Quels appels Object.prototype.hasOwnProperty, mais (a) est plus court à typer, et (b) utilise "une référence sûre à hasOwnProperty"(c'est-à-dire que cela fonctionne même si hasOwnProperty est écrasé).

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

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

235
2017-07-03 17:01



Remarque: le suivant est aujourd'hui largement obsolète grâce au mode strict, et hasOwnProperty. La bonne solution 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édate ces deux choses, au moins aussi largement mis en œuvre (oui, il est si vieux). Prenez ce qui suit comme une note historique.


Gardez à l'esprit que undefined est (malheureusement) ne 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, brisant votre code.

Une méthode plus robuste est donc la suivante:

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

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

Une alternative commune est de s'assurer que undefined est réellement non défini, par ex. en mettant le code dans une fonction qui accepte un paramètre supplémentaire, appelé undefined, ce n'est pas passé une valeur. Pour vous assurer que la valeur n'a pas été dépassée, vous pouvez l'appeler vous-même immédiatement, par exemple:

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

108
2017-09-25 19:48



Qu'en est-il de?

var x = {'key': 1};

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

93
2018-02-02 17:56



if (x.key !== undefined)

Armin Ronacher semble avoir déjà me battre pour ça, 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!');
}

Une solution plus sûre, mais plus lente, Comme indiqué par Konrad Rudolph et Armin Ronacher serait:

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

35
2017-09-25 19:32



Vous pouvez utiliser le in opérateur pour vérifier si la propriété existe sur un objet:

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

Vous pouvez également parcourir toutes les propriétés de l'objet à l'aide d'un for - in boucle, puis vérifiez 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, car les propriétés non énumérables ne s'afficheront pas dans un for-in boucle. En outre, si la propriété énumérable observe une propriété non énumérable du prototype, elle n'apparaîtra pas dans Internet Explorer 8 et plus tôt.

Si vous souhaitez obtenir une liste de toutes les propriétés d'instance, qu'elles soient énumérables ou non, vous pouvez utiliser

Object.getOwnPropertyNames(x);

Cela retournera un tableau de noms de toutes les propriétés qui existent sur un objet.

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

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

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

Mise à jour: Vous pouvez vérifier si une propriété existe en la 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


30
2018-03-30 06:18



Voyons une certaine confusion ici. Tout d'abord, simplifions en supposant hasOwnProperty existe déjà; c'est le cas de la grande majorité des navigateurs actuels.

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

Par conséquent:

var o = {}
o.x = undefined

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

Toutefois:

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 a un attribut avec la valeur indéfinie? hasOwnProperty sera faux pour cela, et ainsi !== undefined. Encore, for..in le listera toujours dans l'énumération.

La ligne de fond est qu'il n'y a pas de manière cross-browser (depuis Internet Explorer n'expose pas __prototype__) pour déterminer qu'un identificateur spécifique n'a pas été attaché à un objet ou à quelque chose dans sa chaîne prototype.


23
2017-09-26 09:16



Si vous recherchez une propriété, alors "NON". Tu veux:

if ('prop' in obj) { }

En général, vous ne devriez pas vous préoccuper de savoir si la propriété provient du prototype ou de l'objet.

Toutefois, comme vous avez utilisé la clé dans votre exemple de code, il semble que vous traitez l'objet comme un hachage, auquel cas votre réponse aurait du sens. Toutes les clés de hachage sont des propriétés dans l'objet, et vous évitez les propriétés supplémentaires apportées par le prototype.

La réponse de John Resig était très complète, mais je pensais que ce n'était pas clair. Surtout quand utiliser "'prop' dans obj".


14
2018-05-21 15:57



Oui c'est :) Je pense que tu peux aussi faire Object.prototype.hasOwnProperty.call(x, 'key') qui devrait aussi fonctionner si xa une propriété appelée hasOwnProperty :)

Mais cela teste pour ses propres propriétés. Si vous voulez vérifier s'il possède une propriété qui peut également être héritée, vous pouvez utiliser typeof x.foo != 'undefined'.


12
2017-09-25 19:30