Comment vérifier si un objet a une propriété spécifique en JavaScript?

Comment vérifier si un objet a une propriété spécifique en JavaScript?

Considérer:

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

Est-ce la meilleure façon de procéder?

Je suis vraiment confus par les réponses qui ont été données - la plupart d'entre elles sont tout simplement 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 chèque de 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 recherchez. 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), alorsobject.hasOwnProperty c'est la voie à suivre. Tous les navigateurs modernes le prennent en charge. (Il manquait dans les anciennes versions de Safari - 2.0.1 et antérieures - mais ces versions du navigateur ne sont plus rarement utilisées.)

Si ce que vous recherchez, c'est si un objet a une propriété itérative (lorsque vous parcourez les propriétés de l'objet, il apparaîtra), puis faites: prop in object vous donnera l'effet souhaité.

Étant donné que l'utilisation hasOwnPropertyest probablement ce que vous voulez, et considérant que vous pouvez souhaiter une méthode de secours, 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 une solution multi-navigateur qui fonctionne hasOwnProperty, avec une mise en garde: il ne peut pas distinguer les cas où une propriété identique se trouve sur le prototype et sur l'instance - il suppose simplement qu'elle provient du prototype. Vous pouvez la modifier pour qu'elle soit plus clémente ou stricte, en fonction de votre situation, mais au moins cela devrait être plus utile.

Avec Underscore.jsou ( 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" (c'est-à-dire qu'il fonctionne même s'il hasOwnPropertyest écrasé).

En particulier, lodash définit _.hascomme:

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

Qu'en est-il de?

var x = {'key': 1};

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

Remarque : ce qui suit est aujourd'hui largement obsolète grâce au mode strict, et hasOwnProperty. La bonne solution consiste à utiliser le mode strict et à vérifier la présence d'une propriété à l'aide de obj.hasOwnProperty. Cette réponse est antérieure à ces deux choses, au moins aussi largement mises en œuvre (oui, c'est aussi ancien). Prenez ce qui suit comme une note historique.

Gardez à l'esprit que ce undefinedn'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, de casser 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 aussi plus lente. : - /

Une alternative courante consiste à s'assurer qu'il undefinedn'est pas réellement défini, par exemple en plaçant le code dans une fonction qui accepte un paramètre supplémentaire, appelé undefined, auquel aucune valeur n'est transmise. Pour vous assurer qu'il ne soit 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 …
})();

if (x.key !== undefined)

Armin Ronacher semble m'avoir déjà battu , 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 plus sûre, mais une solution plus lente, 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' inopé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'une for - inboucle, puis rechercher la propriété spécifique:

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

Vous devez déterminer si cette propriété d'objet est énumérable ou non, car les propriétés non énumérables n'apparaîtront pas dans une for-inboucle. De plus, si la propriété énumérable recouvre une propriété non énumérable du prototype, elle n'apparaîtra pas dans Internet Explorer 8 et versions antérieures.

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

Object.getOwnPropertyNames(x);

Cela renverra 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 renverra la chaîne non définie. Sinon, il renverra 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é définie sur undefined, auquel cas, l'utilisation typeof x.keyretournerait toujours true (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 sauf si la clé a été spécifiquement définie undefinedsur l'objet x

Supprimons ici une certaine confusion. Tout d'abord, simplifions en supposant hasOwnPropertyqu'il existe déjà; cela est vrai de la grande majorité des navigateurs actuellement utilisés.

hasOwnPropertyrenvoie true si le nom d'attribut qui lui est transmis a été ajouté à l'objet. Elle est entièrement indépendante de la valeur réelle qui lui est attribuée, ce 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 ce qui se passe quand un objet de la chaîne prototype a un attribut avec la valeur indéfinie? hasOwnPropertysera faux pour cela, et il en sera de même !== undefined. Encore,for..in listera toujours dans l'énumération.

L'essentiel est qu'il n'y a pas de moyen multi-navigateur (car Internet Explorer ne l'expose pas __prototype__) pour déterminer qu'un identifiant spécifique n'a pas été attaché à un objet ou quoi que ce soit dans sa chaîne de prototype.

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

if ('prop' in obj) { }

En général, vous ne devez pas vous soucier de savoir si la propriété provient ou non du prototype ou de l'objet.

Cependant, comme vous avez utilisé «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 seraient 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 avec quand utiliser "'prop' in obj".

Pour tester des objets simples, utilisez: if (obj[x] !== undefined)

Si vous ne savez pas de quel type d'objet il s'agit: if (obj.hasOwnProperty(x))

Toutes les autres options sont plus lentes ..

Détails

Évaluation des performances de 100 000 000 de cycles sous Nodejs pour les 5 options suggérées par d'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 que si nous ne voulons pas spécifiquement vérifier la chaîne prototype de l'objet ainsi que l'objet lui-même, nous ne devons pas utiliser la forme courante: if (X in Obj)... elle est entre 2 à 6 fois plus lente 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 résumé, si votre Obj n'est pas nécessairement un simple objet et que vous souhaitez éviter de vérifier la chaîne prototype de l'objet et vous assurer que x appartient directement à Obj, utilisez `` if (obj.hasOwnProperty (x)) ... ''.

Sinon, lorsque vous utilisez un objet simple et ne vous inquiétez pas de la chaîne de prototype de l'objet, utilisez 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 bizarre, j'utiliserais if (obj[x])... car je le trouve beaucoup plus lisible.

S'amuser.

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

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

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

}

Parce que

if (x.key)

échoue si x.keyrésout false(par exemple x.key = "").

Vous pouvez également utiliser l' Reflectobjet ES6 :

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

La documentation sur MDN pour Reflect.haspeut être trouvée ici .

La Reflect.has()méthode statique fonctionne comme l' opérateur in en tant que fonction.

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

if (x.hasOwnProperty('key'))

Voici quelques autres options pour inclure des propriétés héritées:

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

if (x.key !== undefined)

Ne faites pas cela object.hasOwnProperty(key)), c'est vraiment mauvais parce que ces méthodes peuvent être masquées par des propriétés sur l'objet en question - considérez { hasOwnProperty: false }- ou, l'objet peut être un objet nul (Object.create(null)).

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

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

Une autre façon relativement simple consiste à utiliser Object.keys. Cela renvoie un arrayqui 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 une excellente prise en charge du navigateur. Parce que cette question est si ancienne, j'ai pensé ajouter ceci: Ceci est sûr à utiliser depuis JS v1.8.5

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

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

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

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

J'espère que ça aide.

Avec un risque de vote en aval massif, voici une autre option pour un cas spécifique. :)

Si vous souhaitez tester un membre sur un objet et savoir s'il a été défini sur autre chose que:

• ''
• faux
• nul
• indéfini
• 0 ...

alors vous pouvez utiliser:

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

Solution ECMA Script 6 avec réflexion. Créez un wrapper 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 existe une méthode "hasOwnProperty" existe sur l'objet, mais il n'est pas recommandé d'appeler cette méthode directement car il se peut que parfois l'objet soit nul ou qu'une propriété existe sur l'objet comme: { hasOwnProperty: false }

La meilleure façon serait donc:

// 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"));

Vous pouvez utiliser les approches suivantes-

var obj = {a:1}
console.log('a' in obj)               //1
console.log(obj.hasOwnProperty('a'))  //2
console.log(Boolean(obj.a))         //3

Les différences entre les approches suivantes sont les suivantes:

1. Dans la 1ère et la 3ème approche, nous ne recherchons pas seulement un objet, mais aussi sa chaîne prototypique. Si l'objet n'a pas la propriété, mais que la propriété est présente dans sa chaîne de prototype, elle va donner la valeur true.

 var obj = {
      a:2,
      __proto__ :{b:2}
    }

    console.log('b' in obj)
    console.log(Boolean(obj.b))

2. La 2ème approche ne vérifiera que ses propres propriétés. Ex -

var obj = {
      a:2,
      __proto__ :{b:2}
    }

    console.log(obj.hasOwnProperty('b'))

3. La différence entre le 1er et le troisième est que s'il existe une propriété qui a une valeur indéfinie, la 3ème approche va donner false tandis que la première donnera true.

var obj = {
      b : undefined
    }
    console.log(Boolean(obj.b))
    console.log('b' in obj);

Vous devez utiliser la méthode object.hasOwnProperty(property). Elle renvoie true si l'objet a la propriété et false si l'objet ne l'est pas.

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

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

Pourquoi trop compliquer les choses quand vous pouvez le faire:

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

Simple et clair pour la plupart des cas ...