Object.prototype.hasOwnProperty() — Methode · JavaScript-Referenz

Signatur

Object.prototype.hasOwnProperty(prop)

Beschreibung

hasOwnProperty() gibt true zurück, wenn die Eigenschaft direkt auf dem Objekt definiert ist. Dabei spielt der Wert keine Rolle: Auch Eigenschaften mit dem Wert undefined oder null zählen. Geerbte Eigenschaften, etwa toString aus Object.prototype, liefern false. Nicht aufzählbare eigene Eigenschaften (z. B. length eines Arrays) zählen dagegen als eigene Eigenschaften.

Der Unterschied zum in-Operator: in durchsucht die gesamte Prototypenkette, hasOwnProperty() nur das Objekt selbst. Deshalb nutzt man die Methode vor allem in for...in-Schleifen, um geerbte Eigenschaften auszufiltern, und bei Objekten, die als Wörterbuch (Schlüssel-Wert-Speicher) dienen.

Seit ES2022 gibt es Object.hasOwn(obj, prop). Diese statische Methode macht dasselbe, ist aber robuster: Sie funktioniert auch bei Objekten ohne Prototyp (Object.create(null)) und bei Objekten, die hasOwnProperty überschrieben haben. In neuem Code sollte man Object.hasOwn() bevorzugen.

Parameter

Name	Typ	Default	Beschreibung
$prop Pflicht	string \| symbol		Name der Eigenschaft als String oder `Symbol`. Andere Werte wie Zahlen werden in einen String umgewandelt (`1` → `"1"`).

Beispiele

Eigene und geerbte Eigenschaften unterscheiden

const user = { name: 'Anna', email: undefined };

console.log(user.hasOwnProperty('name'));     // eigene Eigenschaft
console.log(user.hasOwnProperty('email'));    // eigene Eigenschaft, Wert undefined
console.log(user.hasOwnProperty('toString')); // geerbt von Object.prototype
console.log('toString' in user);              // in prüft die Prototypenkette

true true false true

Geerbte Eigenschaften in for...in ausfiltern

const defaults = { theme: 'dark', lang: 'de' };
const settings = Object.create(defaults);
settings.lang = 'en';
settings.fontSize = 14;

for (const key in settings) {
  if (Object.prototype.hasOwnProperty.call(settings, key)) {
    console.log(`eigene Einstellung: ${key} = ${settings[key]}`);
  }
}

eigene Einstellung: lang = en eigene Einstellung: fontSize = 14

Sicherer Aufruf bei Objekten ohne Prototyp

const cache = Object.create(null);
cache.hasOwnProperty = 'überschrieben';
cache.userId = 42;

// cache.hasOwnProperty('userId') würde einen TypeError werfen
console.log(Object.prototype.hasOwnProperty.call(cache, 'userId'));

// Moderne Variante ab ES2022
console.log(Object.hasOwn(cache, 'userId'));
console.log(Object.hasOwn(cache, 'missing'));

true true false

Arrays und Symbole

const list = ['a', 'b'];
const id = Symbol('id');
const item = { [id]: 7 };

console.log(list.hasOwnProperty(0));        // Index wird zu '0'
console.log(list.hasOwnProperty('length')); // nicht aufzählbar, aber eigene Eigenschaft
console.log(list.hasOwnProperty('map'));    // geerbt von Array.prototype
console.log(item.hasOwnProperty(id));

true true false true

// Wichtig · Fallstricke

Kein Schutz des Namens: hasOwnProperty ist kein reserviertes Wort. Ein Objekt kann die Methode überschreiben, z. B. mit { hasOwnProperty: () => false }. Dann liefert der Aufruf falsche Ergebnisse oder wirft einen Fehler. Bei Daten aus fremden Quellen (JSON, Benutzereingaben) sollte man deshalb immer Object.prototype.hasOwnProperty.call(obj, key) oder Object.hasOwn(obj, key) verwenden. ESLint warnt davor mit der Regel no-prototype-builtins.
Objekte ohne Prototyp: Bei Object.create(null) fehlt die Methode ganz. obj.hasOwnProperty(...) wirft dann einen TypeError.
Getter in Klassen: Getter und Methoden einer Klasse liegen auf dem Prototyp. Für Instanzen liefert hasOwnProperty() daher false. Klassenfelder dagegen sind eigene Eigenschaften.
Proxies: Bei einem Proxy ruft die Methode den Trap getOwnPropertyDescriptor auf, nicht den Trap has.
Kompatibilität: hasOwnProperty() läuft in allen Browsern und in Node.js. Object.hasOwn() gibt es erst ab Chrome 93, Firefox 92, Safari 15.4 und Node.js 16.9.

Siehe auch

Object.hasOwn() in for...in Object.keys() Object.getOwnPropertyNames() Object.prototype.propertyIsEnumerable()