Object.prototype.hasOwnProperty()
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 hasOwnProperty()
-Methode von Object
-Instanzen gibt einen booleschen Wert zurück, der angibt, ob dieses Objekt die angegebene Eigenschaft als eigene Eigenschaft besitzt (im Gegensatz dazu, sie zu erben).
Hinweis: Object.hasOwn()
wird gegenüber hasOwnProperty()
empfohlen, in Browsern, die dies unterstützen.
Probieren Sie es aus
const object1 = {};
object1.property1 = 42;
console.log(object1.hasOwnProperty("property1"));
// Expected output: true
console.log(object1.hasOwnProperty("toString"));
// Expected output: false
console.log(object1.hasOwnProperty("hasOwnProperty"));
// Expected output: false
Syntax
hasOwnProperty(prop)
Parameter
Rückgabewert
Gibt true
zurück, wenn das Objekt die angegebene Eigenschaft als eigene Eigenschaft besitzt; andernfalls false
.
Beschreibung
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 wurde oder überhaupt nicht deklariert ist. Im Gegensatz zum in
-Operator überprüft diese Methode nicht auf die angegebene Eigenschaft in der Prototyp-Kette des Objekts.
Die Methode kann auf den meisten JavaScript-Objekten aufgerufen werden, da die meisten Objekte von Object
abstammen und somit dessen Methoden erben. Zum Beispiel ist Array
ein Object
, und Sie können die Methode hasOwnProperty()
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, in denen sie neu implementiert wurde, oder in null
-Prototype-Objekten (da diese nicht von Object.prototype
erben). Beispiele für diese Fälle sind weiter unten gegeben.
Beispiele
Verwendung von hasOwnProperty, um das Vorhandensein einer eigenen Eigenschaft zu testen
Der folgende Code zeigt, wie man feststellen kann, ob das Objekt example
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
Direkte vs. geerbte Eigenschaften
Das folgende Beispiel unterscheidet zwischen direkten Eigenschaften und Eigenschaften, die über die Prototyp-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
Iteration über die Eigenschaften eines Objekts
Das folgende Beispiel zeigt, wie über die aufzählbaren Eigenschaften eines Objekts iteriert werden kann, ohne dass dabei 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 aufzählbare Elemente iteriert: Das Fehlen von nicht aufzählbaren Eigenschaften in der Schleife bedeutet nicht, dass hasOwnProperty
an sich streng auf aufzählbare Elemente beschränkt ist. Sie können über nicht aufzählbare Eigenschaften mit Object.getOwnPropertyNames()
iterieren.
Verwendung von hasOwnProperty als Eigenschaftsname
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
Der empfohlene Weg, dieses Problem zu überwinden, ist die Verwendung von Object.hasOwn()
(in unterstützenden Browsern). Andere Alternativen sind das Verwenden 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.
Mit Object.create(null) erstellte Objekte
null
-Prototype-Objekte erben nicht von Object.prototype
, wodurch hasOwnProperty()
nicht verfügbar ist.
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: Verwenden Sie bevorzugt Object.hasOwn()
, andernfalls verwenden Sie ein externes Objekt, um auf hasOwnProperty()
zuzugreifen.
Spezifikationen
Specification |
---|
ECMAScript® 2025 Language Specification # sec-object.prototype.hasownproperty |
Browser-Kompatibilität
Report problems with this compatibility data on GitHubdesktop | mobile | server | ||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
hasOwnProperty |
Legend
Tip: you can click/tap on a cell for more information.
- Full support
- Full support