Object.hasOwn()

Baseline Widely available

This feature is well established and works across many devices and browser versions. It’s been available across browsers since July 2015.

Die Object.hasOwn() statische Methode gibt true zurück, wenn das angegebene Objekt die angegebene Eigenschaft als eigene Eigenschaft besitzt. Wenn die Eigenschaft vererbt wird oder nicht existiert, gibt die Methode false zurück.

Note: Object.hasOwn() ist als Ersatz für Object.prototype.hasOwnProperty() gedacht.

Probieren Sie es aus

const object1 = {
  prop: "exists",
};

console.log(Object.hasOwn(object1, "prop"));
// Expected output: true

console.log(Object.hasOwn(object1, "toString"));
// Expected output: false

console.log(Object.hasOwn(object1, "undeclaredPropertyValue"));
// Expected output: false

Syntax

Object.hasOwn(obj, prop)

Parameter

obj: Die JavaScript-Objektinstanz, die getestet werden soll.
prop: Der String-Name oder Symbol der zu testenden Eigenschaft.

Rückgabewert

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

Beschreibung

Die Object.hasOwn() Methode gibt true zurück, wenn die angegebene Eigenschaft eine direkte Eigenschaft des Objekts ist — selbst wenn der Eigenschaftswert null oder undefined ist. Die Methode gibt false zurück, wenn die Eigenschaft vererbt wird oder überhaupt nicht deklariert wurde. Im Gegensatz zum in-Operator prüft diese Methode nicht die angegebene Eigenschaft in der Prototypenkette des Objekts.

Es wird über Object.prototype.hasOwnProperty() empfohlen, weil sie für null-Prototyp-Objekte und mit Objekten funktioniert, die die vererbte hasOwnProperty() Methode überschrieben haben. Während es möglich ist, diese Probleme durch den Aufruf von Object.prototype.hasOwnProperty() auf einem externen Objekt zu umgehen, ist Object.hasOwn() intuitiver.

Beispiele

Verwendung von hasOwn, um das Vorhandensein einer Eigenschaft zu testen

Der folgende Code zeigt, wie man feststellt, 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

Direkte vs. vererbte Eigenschaften

Das folgende Beispiel unterscheidet zwischen direkten Eigenschaften und Eigenschaften, die durch die Prototypenkette vererbt werden:

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

Über die Eigenschaften eines Objekts iterieren

Um über die aufzählbaren Eigenschaften eines Objekts zu iterieren, sollten Sie Folgendes 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() nutzen, um die vererbten Eigenschaften zu überspringen:

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

Überprüfen, ob ein Array-Index existiert

Die Elemente eines Array werden als direkte Eigenschaften definiert, daher können Sie die hasOwn() Methode verwenden, um zu überprü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

Problematische Fälle für hasOwnProperty

Dieser Abschnitt zeigt, dass hasOwn() unempfindlich gegenüber den Problemen 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() unzugä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.
}

Spezifikationen

Specification
ECMAScript® 2025 Language Specification # sec-object.hasown