Wie prüfe ich, ob ein Objekt eine bestimmte Eigenschaft in JavaScript hat?

Question

Wie prüfe ich, ob ein Objekt eine bestimmte Eigenschaft in JavaScript hat?

Bedenken Sie:

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

Ist das der beste Weg?

Answer 1

Ich bin wirklich verwirrt von den Antworten, die gegeben wurden - die meisten von ihnen sind schlichtweg falsch. Natürlich kann man Objekteigenschaften haben, die undefinierte, null oder falsche Werte haben. Also reduziert man einfach die Eigenschaftsprüfung auf typeof this[property] oder, noch schlimmer, x.key wird Ihnen völlig irreführende Ergebnisse liefern.

Das hängt davon ab, was Sie suchen. Wenn Sie wissen wollen, ob ein Objekt physisch eine Eigenschaft enthält (und diese nicht von irgendwo oben in der Prototypenkette stammt), dann object.hasOwnProperty ist der richtige Weg. Alle modernen Browser unterstützen es. (In älteren Versionen von Safari - 2.0.1 und älter - fehlte sie, aber diese Versionen des Browsers werden kaum noch verwendet).

Wenn Sie nach einer Eigenschaft eines Objekts suchen, die iterierbar ist (wenn Sie über die Eigenschaften des Objekts iterieren, wird sie angezeigt), dann tun Sie das: prop in object wird die gewünschte Wirkung erzielen.

Da die Verwendung von hasOwnProperty ist wahrscheinlich das, was Sie wollen, und wenn man bedenkt, dass Sie vielleicht eine Ausweichmethode brauchen, stelle ich Ihnen die folgende Lösung vor:

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

Dies ist eine funktionierende, browserübergreifende Lösung für hasOwnProperty mit einer Einschränkung: Es ist nicht in der Lage, zwischen Fällen zu unterscheiden, in denen eine identische Eigenschaft im Prototyp und in der Instanz vorhanden ist - es wird einfach angenommen, dass sie vom Prototyp stammt. Sie können es je nach Situation nachsichtiger oder strenger machen, aber zumindest sollte dies hilfreicher sein.

Answer 2

Con Underscore.js oder ( noch besser ) Lodash :

_.has(x, 'key');

Welche Anrufe Object.prototype.hasOwnProperty aber (a) ist kürzer in der Schreibweise und (b) verwendet "einen sicheren Verweis auf hasOwnProperty " (d.h. es funktioniert auch, wenn hasOwnProperty überschrieben wird).

Insbesondere definiert Lodash _.has comme :

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

Answer 3

Utilizar:

var x = {
  'key': 1
};

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

Answer 4

Hinweis : Das Folgende ist heute dank des Strict Mode weitgehend überholt, und hasOwnProperty . Die korrekte Lösung ist die Verwendung des Strict-Modus und die Überprüfung auf das Vorhandensein einer Eigenschaft mit obj.hasOwnProperty . Diese Antwort vor beides, zumindest in der weit verbreiteten Form (ja, es ist so alt). Nehmen Sie das Folgende als eine historische Anmerkung.

---

Bitte beachten Sie, dass undefined ist (leider) no ein reserviertes Wort in JavaScript, wenn Sie nicht den Strict-Modus verwenden. Daher könnte jemand (natürlich jemand anderes) auf die grandiose Idee kommen, es neu zu definieren und damit Ihren Code zu zerstören.

Eine robustere Methode ist daher die folgende:

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

Auf der anderen Seite ist diese Methode sehr viel ausführlicher und auch langsamer :-/

Eine gängige Alternative besteht darin, sicherzustellen, dass undefined es eigentlich undefiniert, z.B. durch Einfügen des Codes in eine Funktion, die einen zusätzlichen Parameter akzeptiert, der undefined die nicht mit einem Wert versehen ist. Um sicherzugehen, dass kein Wert übergeben wird, können Sie es einfach selbst sofort aufrufen, z. B.:

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

Answer 5

if (x.key !== undefined)

Armin Ronacher scheint bereits mir zuvorgekommen , sondern:

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!');
}

Eine sicherere, aber langsamere Lösung, wie hervorgehoben por Konrad Rudolph y Armin Ronacher wäre:

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