Object.prototype.hasOwnProperty()
Die hasOwnProperty()
Methode von Object
Instanzen gibt einen Boolean zurück, der anzeigt, ob dieses Objekt die angegebene Eigenschaft als eigene Eigenschaft hat (im Gegensatz dazu, sie zu erben).
Note:
Object.hasOwn()
wird überhasOwnProperty()
empfohlen, in Browsern, die es unterstützen.
Probieren Sie es aus
Syntax
hasOwnProperty(prop)
Parameter
Rückgabewert
Gibt true
zurück, wenn das Objekt die angegebene Eigenschaft als eigene Eigenschaft hat; andernfalls false
.
Beschreibung
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 geerbt ist oder gar nicht erklärt wurde. Im Gegensatz zum in
Operator prüft diese Methode nicht die angegebene Eigenschaft in der Prototypenkette 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
, sodass Sie die hasOwnProperty()
Methode verwenden können, um zu prüfen, ob ein Index existiert:
const fruits = ["Apple", "Banana", "Watermelon", "Orange"];
fruits.hasOwnProperty(3); // true ('Orange')
fruits.hasOwnProperty(4); // false - not defined
Die Methode wird nicht verfügbar sein in Objekten, wo sie neu implementiert wird, oder auf null
-Prototyp-Objekten (da diese nicht von Object.prototype
erben). Beispiele für diese Fälle werden unten gegeben.
Beispiele
Verwendung von hasOwnProperty zur Überprüfung auf das Vorhandensein einer eigenen Eigenschaft
Der folgende Code zeigt, wie man feststellt, ob das example
Objekt 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 durch die Prototypenkette geerbt werden:
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
Iterieren über die Eigenschaften eines Objekts
Das folgende Beispiel zeigt, wie man über die aufzählbaren Eigenschaften eines Objekts iteriert, ohne geerbte 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 aufzählbaren Eigenschaften, die von der Schleife ausgegeben werden, impliziert nicht, dass hasOwnProperty
selbst strikt auf aufzählbare Elemente beschränkt ist. Sie können über nicht aufzählbare Eigenschaften mit Object.getOwnPropertyNames()
iterieren.
Nutzung 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
Die empfohlene Methode, um dieses Problem zu umgehen, ist stattdessen die Verwendung von Object.hasOwn()
(in Browsern, die es unterstützen). 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 neu erzeugten Objekte vorhanden sind.
Objekte, die mit Object.create(null) erstellt wurden
null
-Prototyp-Objekte erben nicht von Object.prototype
, wodurch hasOwnProperty()
unzugänglich 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 das hasOwnProperty()
eines externen Objekts.
Spezifikationen
Specification |
---|
ECMAScript Language Specification # sec-object.prototype.hasownproperty |
Browser-Kompatibilität
BCD tables only load in the browser