HTML: Markup language
CSS: Styling language
JavaScript: Scripting language
Web APIs: Programming interfaces
All web technology
Learn web development
Discover our tools
Get to know MDN better
Dieser Inhalt wurde automatisch aus dem Englischen übersetzt, und kann Fehler enthalten. Erfahre mehr über dieses Experiment.
View in English Always switch to English
Diese Funktion ist gut etabliert und funktioniert auf vielen Geräten und in vielen Browserversionen. Sie ist seit Juli 2015 browserübergreifend verfügbar.
Die hasOwnProperty()-Methode von Object Instanzen gibt einen booleschen Wert zurück, der angibt, ob dieses Objekt die angegebene Eigenschaft als eigene Eigenschaft hat (im Gegensatz zum Vererben).
hasOwnProperty()
Object
Hinweis: Object.hasOwn() wird über hasOwnProperty() empfohlen, in Browsern, die es unterstützen.
Object.hasOwn()
const object = {}; object.foo = 42; console.log(object.hasOwnProperty("foo")); // Expected output: true console.log(object.hasOwnProperty("toString")); // Expected output: false console.log(object.hasOwnProperty("hasOwnProperty")); // Expected output: false
hasOwnProperty(prop)
prop
Der String-Name oder das Symbol der zu testenden Eigenschaft.
String
Gibt true zurück, wenn das Objekt die angegebene Eigenschaft als eigene Eigenschaft hat; andernfalls false.
true
false
Die hasOwnProperty()-Methode 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 vererbt wurde oder überhaupt nicht deklariert wurde. Im Gegensatz zum in Operator prüft diese Methode nicht die angegebene Eigenschaft in der Prototypen-Kette des Objekts.
null
undefined
in
Die Methode kann auf den meisten JavaScript-Objekten aufgerufen werden, da die meisten Objekte von Object abstammen und daher dessen Methoden erben. Zum Beispiel ist Array ein Object, sodass Sie die hasOwnProperty()-Methode verwenden können, um zu prüfen, ob ein Index existiert:
Array
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 wird, oder bei null-Prototyp-Objekten (da diese nicht von Object.prototype erben). Beispiele für diese Fälle sind unten angegeben.
Object.prototype
Der folgende Code zeigt, wie ermittelt werden kann, ob das example-Objekt eine Eigenschaft mit dem Namen prop enthält.
example
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 Eigenschaften, die über die Prototypen-Kette vererbt 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
Das folgende Beispiel zeigt, wie über die aufzählbaren Eigenschaften eines Objekts iteriert werden kann ohne vererbte 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 über aufzählbare Elemente iteriert: das Fehlen von nicht-auflistbaren Eigenschaften, die aus der Schleife ausgegeben werden, impliziert nicht, dass hasOwnProperty selbst streng auf aufzählbare Elemente beschränkt ist. Sie können über nicht-auflistbare Eigenschaften mit Object.getOwnPropertyNames() iterieren.
for...in
hasOwnProperty
Object.getOwnPropertyNames()
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 unterstützenden Browsern). Andere Alternativen beinhalten 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-Prototyp-Objekte erben nicht von Object.prototype, was hasOwnProperty() unzugänglich macht.
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() bevorzugt, andernfalls verwenden Sie das hasOwnProperty() eines externen Objekts.
JavaScript aktivieren, um diese Browser-Kompatibilitätstabelle anzuzeigen.