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 statische Methode Object.hasOwn() gibt true zurück, wenn das angegebene Objekt die angegebene Eigenschaft als eigene Eigenschaft besitzt. Falls die Eigenschaft geerbt ist oder nicht existiert, gibt die Methode false zurück.

Hinweis: 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

js
Object.hasOwn(obj, prop)

Parameter

obj

Die JavaScript-Objektinstanz, die überprüft werden soll.

prop

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

Rückgabewert

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

Beschreibung

Die Methode Object.hasOwn() 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 geerbt ist oder überhaupt nicht existiert. Im Gegensatz zum in-Operator überprüft diese Methode nicht, ob die angegebene Eigenschaft in der Prototypkette des Objekts vorhanden ist.

Die Methode wird gegenüber Object.prototype.hasOwnProperty() empfohlen, da sie mit null-Prototyp-Objekten und Objekten funktioniert, die die geerbte Methode hasOwnProperty() überschrieben haben. Während es möglich ist, diese Probleme zu umgehen, indem Object.prototype.hasOwnProperty() auf einem externen Objekt aufgerufen wird, ist Object.hasOwn() intuitiver.

Beispiele

Verwendung von hasOwn zum Überprüfen auf die Existenz einer Eigenschaft

Der folgende Code zeigt, wie überprüft werden kann, ob das Objekt example eine Eigenschaft namens prop enthält.

js
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. geerbte Eigenschaften

Das folgende Beispiel unterscheidet zwischen direkten Eigenschaften und Eigenschaften, die über die Prototypkette geerbt wurden:

js
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

Iteration über die Eigenschaften eines Objekts

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

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

Wenn Sie jedoch for...in verwenden müssen, können Sie Object.hasOwn() nutzen, um die geerbten Eigenschaften zu überspringen:

js
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 sind als direkte Eigenschaften definiert, daher können Sie die Methode hasOwn() verwenden, um zu überprüfen, ob ein bestimmter Index existiert:

js
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

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

js
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 haben daher keinen Zugriff auf hasOwnProperty().

js
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

Browser-Kompatibilität

Report problems with this compatibility data on GitHub
desktopmobileserver
Chrome
Edge
Firefox
Opera
Safari
Chrome Android
Firefox for Android
Opera Android
Safari on iOS
Samsung Internet
WebView Android
WebView on iOS
Deno
Node.js
hasOwn

Legend

Tip: you can click/tap on a cell for more information.

Full support
Full support

Siehe auch