Object.prototype.hasOwnProperty()

prop

Der String Name oder das Symbol der zu prüfenden Eigenschaft.

Gibt true zurück, wenn das Objekt die angegebene Eigenschaft als eigene Eigenschaft hat; andernfalls false.

Die hasOwnProperty() Methode gibt true zurück, wenn die angegebene Eigenschaft eine direkte Eigenschaft des Objekts ist — auch wenn der Wert null oder undefined ist. Die Methode gibt false zurück, wenn die Eigenschaft geerbt ist oder überhaupt nicht deklariert wurde. Im Gegensatz zum in Operator überprüft diese Methode nicht die angegebene Eigenschaft in der Prototypen-Kette des Objekts.

Die Methode kann auf den meisten JavaScript-Objekten aufgerufen werden, da die meisten Objekte von Object abstammen und daher seine Methoden erben. Zum Beispiel ist Array ein Object, sodass Sie die hasOwnProperty() Methode verwenden können, um zu prüfen, ob ein Index existiert:

const fruits = ["Apple", "Banana", "Watermelon", "Orange"];
fruits.hasOwnProperty(3); // true ('Orange')
fruits.hasOwnProperty(4); // false - not defined

Die Methode ist nicht verfügbar bei Objekten, bei denen sie neu implementiert wird, oder bei null-Prototyp Objekten (da diese nicht von Object.prototype erben). Beispiele für diese Fälle werden unten angegeben.

Der folgende Code zeigt, wie Sie feststellen können, ob das example Objekt eine Eigenschaft namens prop enthält.

const example = {};
example.hasOwnProperty("prop"); // false

example.prop = "exists";
example.hasOwnProperty("prop"); // true - 'prop' has been defined

example.prop = null;
example.hasOwnProperty("prop"); // true - own property exists with value of null

example.prop = undefined;
example.hasOwnProperty("prop"); // true - own property exists with value of undefined

Das folgende Beispiel unterscheidet zwischen direkten Eigenschaften und Eigenschaften, die über die Prototypen-Kette geerbt wurden:

const example = {};
example.prop = "exists";

// `hasOwnProperty` will only return true for direct properties:
example.hasOwnProperty("prop"); // true
example.hasOwnProperty("toString"); // false
example.hasOwnProperty("hasOwnProperty"); // false

// The `in` operator will return true for direct or inherited properties:
"prop" in example; // true
"toString" in example; // true
"hasOwnProperty" in example; // true

Das folgende Beispiel zeigt, wie über die aufzählbaren Eigenschaften eines Objekts iteriert werden kann, ohne dass auf geerbte Eigenschaften zugegriffen wird.

const buz = {
  fog: "stack",
};

for (const name in buz) {
  if (buz.hasOwnProperty(name)) {
    console.log(`this is fog (${name}) for sure. Value: ${buz[name]}`);
  } else {
    console.log(name); // toString or something else
  }
}

Beachten Sie, dass die for...in Schleife nur über aufzählbare Elemente iteriert: Das Fehlen von nicht aufzählbaren Eigenschaften, die aus der Schleife ausgelassen werden, bedeutet nicht, dass hasOwnProperty selbst ausschließlich auf aufzählbare Elemente beschränkt ist. Sie können über nicht aufzählbare Eigenschaften mit Object.getOwnPropertyNames() iterieren.

JavaScript schützt den Eigenschaftsnamen hasOwnProperty nicht; ein Objekt, das über eine Eigenschaft mit diesem Namen verfügt, kann falsche Ergebnisse liefern:

const foo = {
  hasOwnProperty() {
    return false;
  },
  bar: "Here be dragons",
};

foo.hasOwnProperty("bar"); // re-implementation always returns false

Der empfohlene Weg, um dieses Problem zu umgehen, ist die Verwendung von Object.hasOwn() (in unterstützenden Browsern). Andere Alternativen beinhalten die Verwendung einer externen hasOwnProperty:

const foo = { bar: "Here be dragons" };

// Use Object.hasOwn() method - recommended
Object.hasOwn(foo, "bar"); // true

// Use the hasOwnProperty property from the Object prototype
Object.prototype.hasOwnProperty.call(foo, "bar"); // true

// Use another Object's hasOwnProperty
// and call it with 'this' set to foo
({}).hasOwnProperty.call(foo, "bar"); // true

Beachten Sie, dass in den ersten beiden Fällen keine neuen Objekte erstellt werden.

null-Prototyp Objekte erben nicht von Object.prototype, was hasOwnProperty() unzugänglich macht.

const foo = Object.create(null);
foo.prop = "exists";
foo.hasOwnProperty("prop"); // Uncaught TypeError: foo.hasOwnProperty is not a function

Die Lösungen in diesem Fall sind die gleichen wie im vorherigen Abschnitt: bevorzuge die Verwendung von Object.hasOwn(), ansonsten verwende die hasOwnProperty() eines externen Objekts.

• Object.hasOwn()
• Aufzählbarkeit und Besitz von Eigenschaften
• Object.getOwnPropertyNames()
• for...in
• in
• Vererbung und die Prototyp-Kette