Object.hasOwn()

obj

Die zu prüfende JavaScript-Objektinstanz.

prop

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

true, wenn das angegebene Objekt die angegebene Eigenschaft direkt definiert hat. Andernfalls false

Die Methode Object.hasOwn() gibt true zurück, wenn die angegebene Eigenschaft eine direkte Eigenschaft des Objekts ist – auch wenn der Eigenschaftswert 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 prüft diese Methode nicht, ob die angegebene Eigenschaft in der Prototypkette des Objekts vorhanden ist.

Es wird empfohlen, Object.hasOwn() anstelle von Object.prototype.hasOwnProperty() zu verwenden, da es mit null-Prototyp Objekten und mit Objekten funktioniert, die die geerbte Methode hasOwnProperty() überschrieben haben. Obwohl es möglich ist, diese Probleme zu umgehen, indem Object.prototype.hasOwnProperty() auf einem externen Objekt aufgerufen wird, ist Object.hasOwn() intuitiver.

Der folgende Code zeigt, wie zu bestimmen ist, ob das example-Objekt eine Eigenschaft namens prop enthält.

const example = {};
Object.hasOwn(example, "prop"); // false - 'prop' has not been defined

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

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

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

Das folgende Beispiel unterscheidet zwischen direkten Eigenschaften und über die Prototypkette geerbten Eigenschaften:

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

// `hasOwn` will only return true for direct properties:
Object.hasOwn(example, "prop"); // true
Object.hasOwn(example, "toString"); // false
Object.hasOwn(example, "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

Um über die aufzählbaren Eigenschaften eines Objekts zu iterieren, sollten Sie verwenden:

const example = { foo: true, bar: true };
for (const name of Object.keys(example)) {
  // …
}

Aber wenn Sie for...in verwenden müssen, können Sie Object.hasOwn() verwenden, um geerbte Eigenschaften zu überspringen:

const example = { foo: true, bar: true };
for (const name in example) {
  if (Object.hasOwn(example, name)) {
    // …
  }
}

Die Elemente eines Array sind als direkte Eigenschaften definiert, sodass Sie die hasOwn()-Methode verwenden können, um zu prüfen, ob ein bestimmter Index existiert:

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

Dieser Abschnitt zeigt, dass hasOwn() immun gegen die Probleme ist, die hasOwnProperty betreffen. Erstens kann es mit Objekten verwendet werden, die hasOwnProperty() neu implementiert haben:

const foo = {
  hasOwnProperty() {
    return false;
  },
  bar: "The dragons be out of office",
};

if (Object.hasOwn(foo, "bar")) {
  console.log(foo.bar); // true - re-implementation of hasOwnProperty() does not affect Object
}

Es kann auch mit null-Prototyp Objekten verwendet werden. Diese erben nicht von Object.prototype, und daher ist hasOwnProperty() nicht zugänglich.

const foo = Object.create(null);
foo.prop = "exists";
if (Object.hasOwn(foo, "prop")) {
  console.log(foo.prop); // true - works irrespective of how the object is created.
}

• Polyfill von Object.hasOwn in core-js
• Object.prototype.hasOwnProperty()
• Aufzählbarkeit und Besitz von Eigenschaften
• Object.getOwnPropertyNames()
• for...in
• in
• Vererbung und die Prototypkette