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

Question

Donc :

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

Answer 1

Je suis vraiment confus par les réponses qui ont été données de la plupart d'entre eux sont juste carrément erronée. Bien sûr, vous pouvez avoir les propriétés de l'objet ont pas défini, la valeur null ou de fausses valeurs. Donc, il suffit de réduire le bien de vérifier pour typeof this[property] ou, encore pire, x.key va vous donner complètement des résultats trompeurs.

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

Si ce que vous cherchez est de savoir si un objet a une propriété qui est itératif (lorsque vous effectuer une itération sur les propriétés de l'objet, il apparaît), puis de le faire: prop in object va vous donner l'effet désiré.

Depuis l'utilisation de hasOwnProperty est probablement ce que vous voulez, et en considérant que vous voudrez peut-être un repli de la méthode, 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 );
    }
}

Le dessus est un travail, de la croix-navigateur, solution d' hasOwnProperty, avec un bémol: Il est impossible de distinguer entre les cas où un bien identique est sur le prototype et sur l'instance, il a juste suppose que ça vient du prototype. Vous pouvez changer pour être plus indulgent ou sévère, en fonction de votre situation, mais à tout le moins, cela devrait être plus utile.

Answer 2

Avec `` ou (encore mieux) `` :

Qui appelle , mais (a) est plus courte de type et (b) les utilisations « une référence sûre pour "(i.e. il fonctionne même si `` est écrasé).

Answer 3

En quoi consiste ?

Answer 4

Gardez à l'esprit qu' undefined est (malheureusement) pas un mot réservé en JavaScript. Par conséquent, quelqu'un (quelqu'un d'autre, évidemment) pourrait avoir la grande idée de la redéfinir, de casser votre code.

Une méthode plus solide est donc le suivant:

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

Sur le revers de la médaille, cette méthode est beaucoup plus détaillé et aussi plus de temps. :-/

Une alternative est de s'assurer que undefined est en fait défini, par exemple en mettant le code dans une fonction qui accepte un paramètre supplémentaire, appelé undefined, qui n'est pas transmis une valeur. Pour s'assurer qu'il n'est pas transmis une valeur, vous pouvez simplement appeler vous-même immédiatement, par exemple:

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

Answer 5

if (x.key !== undefined)

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