Frage Wie überprüfe ich, ob ein Objekt eine Eigenschaft in JavaScript hat?


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

Erwägen:

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

Ist das der beste Weg?


1180
2017-09-25 19:27


Ursprung


Antworten:


Ich bin wirklich verwirrt über die Antworten, die gegeben wurden - die meisten von ihnen sind einfach nur falsch. Natürlich können Sie Objekteigenschaften mit undefinierten, Null- oder Falschwerten haben. Reduzieren Sie einfach die Eigenschaftsprüfung auf typeof this[property] oder, noch schlimmer, x.key wird Ihnen völlig irreführende Ergebnisse geben.

Es hängt davon ab, wonach Sie suchen. Wenn Sie wissen wollen, ob ein Objekt physikalisch eine Eigenschaft enthält (und es nicht von irgendwo in der Prototypkette kommt), dann object.hasOwnProperty ist der Weg zu gehen. Alle modernen Browser unterstützen es. (Es fehlte in älteren Versionen von Safari - 2.0.1 und älter - aber diese Versionen des Browsers werden selten mehr verwendet.)

Was Sie suchen ist, wenn ein Objekt eine Eigenschaft hat, die iterierbar ist (wenn Sie über die Eigenschaften des Objekts iterieren, wird es angezeigt) und dann tun: prop in object gibt dir deine gewünschte Wirkung.

Seit Verwendung hasOwnProperty ist wahrscheinlich, was Sie wollen, und in Anbetracht dessen, dass Sie eine Fallback-Methode möchten, präsentiere ich Ihnen die folgende Lösung:

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

Das oben genannte ist eine funktionierende, browserübergreifende Lösung für hasOwnProperty, mit einem Vorbehalt: Es ist nicht möglich, zwischen Fällen zu unterscheiden, in denen eine identische Eigenschaft auf dem Prototyp und auf der Instanz ist - es nimmt nur an, dass es vom Prototyp kommt. Sie könnten es je nach Ihrer Situation milder oder strenger machen, aber zumindest sollte es hilfreicher sein.


1202
2017-09-25 21:52



Mit Underscore.js oder (noch besser) lodash:

_.has(x, 'key');

Welche Anrufe? Object.prototype.hasOwnProperty, aber (a) ist kürzer in der Art und (b) verwendet "eine sichere Bezugnahme auf hasOwnProperty"(d. h. es funktioniert auch wenn hasOwnProperty wird überschrieben).

Insbesondere definiert lodash _.has wie:

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

235
2017-07-03 17:01



Hinweis: das folgende ist heutzutage dank strengem Modus, und hasOwnProperty. Die korrekte Lösung besteht darin, den strikten Modus zu verwenden und das Vorhandensein einer Eigenschaft zu prüfen obj.hasOwnProperty. Diese Antwort älter beides ist zumindest so weit verbreitet (ja, so alt ist es). Nehmen Sie Folgendes als historische Notiz.


Bedenke, dass undefined ist leider) nicht ein reserviertes Wort in JavaScript, wenn Sie nicht den strikten Modus verwenden. Daher könnte jemand (jemand anders, offensichtlich) die großartige Idee haben, es neu zu definieren und seinen Code zu brechen.

Eine robustere Methode ist daher Folgendes:

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

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

Eine gängige Alternative ist dies sicherzustellen undefined ist tatsächlich undefiniert, z.B. indem der Code in eine Funktion gesetzt wird, die einen zusätzlichen Parameter akzeptiert, der aufgerufen wird undefined, das ist kein Wert übergeben. Um sicherzustellen, dass der Wert nicht überschritten wird, können Sie ihn sofort selbst anrufen, z.

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

108
2017-09-25 19:48



Wie wäre es mit?

var x = {'key': 1};

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

93
2018-02-02 17:56



if (x.key !== undefined)

Armin Ronacher scheint schon zu haben schlag mich dazu, aber:

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 erwähnt durch Konrad Rudolph und Armin Ronacher wäre:

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

35
2017-09-25 19:32



Du kannst den ... benutzen in Operator, um zu prüfen, ob die Eigenschaft für ein Objekt existiert:

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

Sie können auch alle Eigenschaften des Objekts durchlaufen, indem Sie a verwenden for - in Schleife und dann nach der spezifischen Eigenschaft suchen:

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

Sie müssen prüfen, ob diese Objekteigenschaft aufzählbar ist oder nicht, da nicht aufzählbare Eigenschaften nicht in a angezeigt werden for-in Schleife. Wenn die aufzählbare Eigenschaft eine nicht aufzählbare Eigenschaft des Prototyps überschattet, wird sie auch nicht angezeigt Internet Explorer 8 und früher.

Wenn Sie eine Liste aller Instanzeigenschaften möchten, ob aufzählbar oder nicht, können Sie verwenden

Object.getOwnPropertyNames(x);

Dies gibt ein Array von Namen aller Eigenschaften zurück, die für ein Objekt existieren.

Schließlich können Sie mit dem Operator typeof den Datentyp der Objekteigenschaft direkt überprüfen:

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

Wenn die Eigenschaft für das Objekt nicht vorhanden ist, wird die Zeichenfolge undefined zurückgegeben. Andernfalls wird der entsprechende Eigenschaftstyp zurückgegeben. Beachten Sie jedoch, dass dies nicht immer eine gültige Methode ist, um zu überprüfen, ob ein Objekt eine Eigenschaft besitzt oder nicht, da Sie eine Eigenschaft verwenden können, die in diesem Fall auf undefined festgelegt wird typeof x.key würde immer noch wahr zurückgeben (obwohl der Schlüssel noch im Objekt ist).

Update: Sie können überprüfen, ob eine Eigenschaft vorhanden ist, indem Sie sie mit der Eigenschaft undefined JavaScript vergleichen

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

Dies sollte funktionieren, es sei denn, der Schlüssel wurde speziell festgelegt undefined auf dem x-Objekt


30
2018-03-30 06:18



Lass uns hier einige Verwirrung durchschneiden. Lassen Sie uns zuerst vereinfachen, indem wir annehmen hasOwnProperty ist bereits vorhanden; Dies gilt für die überwiegende Mehrheit der derzeit verwendeten Browser.

hasOwnProperty gibt true zurück, wenn der Attributname, der an das Objekt übergeben wurde, zum Objekt hinzugefügt wurde. Es ist völlig unabhängig von dem tatsächlich zugewiesenen Wert, der genau sein kann undefined.

Daher:

var o = {}
o.x = undefined

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

Jedoch:

var o = {}

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

Das Problem tritt auf, wenn ein Objekt in der Prototypkette ein Attribut mit dem Wert undefined hat? hasOwnProperty wird dafür falsch sein, und so wird !== undefined. Noch, for..in wird es immer noch in der Aufzählung auflisten.

Die Quintessenz ist, dass es keinen Browser-übergreifenden Weg gibt (da Internet Explorer nicht verfügbar ist) __prototype__) um festzustellen, dass ein bestimmter Bezeichner nicht an ein Objekt oder irgendetwas in seiner Prototypkette angehängt wurde.


23
2017-09-26 09:16



Wenn Sie nach einer Immobilie suchen, dann "NEIN". Sie wollen:

if ('prop' in obj) { }

Im Allgemeinen sollte es Ihnen egal sein, ob die Immobilie aus dem Prototyp oder dem Objekt stammt.

Da Sie jedoch in Ihrem Beispielcode "Schlüssel" verwendet haben, sieht es so aus, als ob Sie das Objekt als Hash behandeln. In diesem Fall würde Ihre Antwort Sinn ergeben. Alle Hash-Schlüssel sind Eigenschaften im Objekt, und Sie vermeiden die zusätzlichen Eigenschaften, die vom Prototyp beigetragen werden.

John Resigs Antwort war sehr umfassend, aber ich dachte, es sei nicht klar. Vor allem, wenn "'prop' in obj" verwendet werden soll.


14
2018-05-21 15:57