Object.prototype.hasOwnProperty()

prop

Der String-Name oder Symbol der zu testenden Eigenschaft.

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

Die Methode hasOwnProperty() gibt true zurück, wenn die angegebene Eigenschaft eine direkte Eigenschaft des Objekts ist — selbst wenn der Wert null oder undefined ist. Die Methode gibt false zurück, wenn die Eigenschaft geerbt ist oder überhaupt nicht deklariert wurde. Anders als der in-Operator, prüft diese Methode nicht nach der angegebenen Eigenschaft in der Prototypkette des Objekts.

Die Methode kann auf den meisten JavaScript-Objekten aufgerufen werden, da die meisten Objekte von Object abstammen und daher ihre Methoden erben. Zum Beispiel ist Array ein Object, daher können Sie die hasOwnProperty()-Methode verwenden, um zu überprü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 in Objekten, bei denen sie neu implementiert wurde, oder bei null-Prototype-Objekten (da diese nicht von Object.prototype erben). Beispiele für diese Fälle werden unten gegeben.

Der folgende Code zeigt, wie man feststellt, 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 durch die Prototypkette geerbten Eigenschaften:

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 man über die aufzählbaren Eigenschaften eines Objekts iteriert, ohne geerbte Eigenschaften auszuführen.

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 aufzählbare Elemente iteriert: Das Fehlen von nicht-auflistbaren Eigenschaften in der Schleife bedeutet nicht, dass hasOwnProperty selbst streng auf aufzählbare Elemente beschränkt ist. Sie können über nicht-auflistbare Eigenschaften mit Object.getOwnPropertyNames() iterieren.

JavaScript schützt den Eigenschaftsnamen hasOwnProperty nicht; ein Objekt, das eine Eigenschaft mit diesem Namen hat, kann falsche Ergebnisse zurückgeben:

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

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

Die empfohlene Methode, um dieses Problem zu überwinden, ist die Verwendung von Object.hasOwn() (in Browsern, die es unterstützen). Andere Alternativen umfassen die Verwendung eines 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-Prototype-Objekte erben nicht von Object.prototype, wodurch hasOwnProperty() unzugänglich wird.

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 dieselben wie im vorherigen Abschnitt: Verwenden Sie Object.hasOwn(), falls verfügbar, andernfalls verwenden Sie eine externe Objekts hasOwnProperty().

• Object.hasOwn()
• Enumerierbarkeit und Eigentum von Eigenschaften
• Object.getOwnPropertyNames()
• for...in
• in
• Vererbung und die Prototypkette