WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / JavaScript

Object.prototype, Eigenschaftsdeskriptoren und Accessoren

Unterscheide, wo eine Eigenschaft in der Prototypenkette liegt und wie sie sich verhält: Sie speichert einen Wert oder verwendet einen Getter oder Setter.

Version: ECMAScript 2024 and the current web platform; runtime support varies

Syntax

Object.prototype
Object.getPrototypeOf(obj)
Object.hasOwn(obj, key)
Object.getOwnPropertyDescriptor(obj, key)
Object.defineProperty(obj, key, { value: 1, writable: true, enumerable: true, configurable: true })
Object.defineProperty(obj, key, { get() { return this._value; }, set(value) { this._value = value; }, configurable: true })

Object.prototype ist das gemeinsame Objekt am Ende vieler Prototypenketten, auch der von {}. Sein eigener Prototyp ist null. Ein mit Object.create(null) erzeugtes Objekt erbt nicht davon. Prüfe den direkten Prototyp mit Object.getPrototypeOf(obj) statt mit dem veralteten Accessor __proto__, der fehlen oder verdeckt sein kann. Füge Object.prototype keine Anwendungseigenschaften hinzu: Andere Objekte können sie erben.

Ein Deskriptor beschreibt die Attribute einer Eigenschaft. Eine Dateneigenschaft speichert einen value; writable bestimmt, ob eine Zuweisung ihn ändern kann. Eine Accessor-Eigenschaft hat stattdessen get und set, jeweils eine Funktion oder undefined. Beide Arten haben enumerable (beeinflusst etwa, ob ein eigener Zeichenkettenschlüssel in Object.keys erscheint) und configurable (bestimmt, ob die Eigenschaft löschbar ist, und schränkt Attributänderungen ein). Ein Accessor ist eine Eigenschaftsart, keine Alternative zum Deskriptor.

Bei gewöhnlichen Objekten prüft ein Lesezugriff zuerst eigene Eigenschaften, dann die Prototypenkette. Eine Dateneigenschaft liefert ihren gespeicherten Wert; ein Getter wird bei obj.key mit dem ursprünglichen Objekt als this aufgerufen. Ohne Getter liefert der Zugriff undefined. Eine Zuweisung an einen geerbten Accessor ruft seinen Setter mit demselben this auf; bei einer geerbten schreibbaren Dateneigenschaft entsteht eine eigene Eigenschaft, sofern das Objekt erweiterbar ist. Ein fehlender Setter oder writable: false blockiert die Zuweisung: Im Strict Mode wird TypeError ausgelöst, sonst bleibt die Eigenschaft unverändert.

Object.hasOwn(obj, key) prüft nur eigene Eigenschaften; key in obj berücksichtigt auch geerbte. Object.getOwnPropertyDescriptor(obj, key) liefert ein separates Objekt, das eine eigene Eigenschaft beschreibt, oder undefined, wenn sie fehlt. Bei gewöhnlichen Objekten ruft die Methode den Getter der geprüften Eigenschaft nicht auf. Änderungen an Feldern des zurückgegebenen Deskriptors ändern die Eigenschaft nicht.

Object.defineProperty(obj, key, descriptor) definiert oder aktualisiert eine eigene Eigenschaft, ohne einen geerbten Setter aufzurufen. Bei einer neuen Eigenschaft sind ausgelassene Flags writable (für Daten), enumerable und configurable standardmäßig false; beim Aktualisieren ohne Wechsel der Eigenschaftsart behalten ausgelassene Attribute ihre Werte. Wer value oder writable mit get oder set kombiniert oder eine unzulässige Neudefinition versucht, löst auch außerhalb des Strict Mode TypeError aus.

Beispiele

(() => {
  'use strict';
  const proto = {
    points: 2,
    get score() { return this.points * 2; },
    set score(value) { this.points = value / 2; }
  };
  const player = Object.create(proto);
  const accessor = Object.getOwnPropertyDescriptor(proto, 'score');
  console.log(`${'score' in player} ${Object.hasOwn(player, 'score')} ${typeof accessor.get}`);

  player.score = 12;
  console.log(`${player.score} ${player.points} ${proto.points}`);

  Object.defineProperty(player, 'score', { value: 99 });
  const data = Object.getOwnPropertyDescriptor(player, 'score');
  console.log(`${player.score} ${player.points} ${data.writable} ${data.enumerable} ${data.configurable}`);
})();

Ergebnis

true false function
12 6 2
99 6 false false false

Der Setter `score` schreibt die eigene Eigenschaft `player.points`, ohne `proto.points` zu ändern. Anschließend verdeckt `Object.defineProperty` den Accessor mit einer eigenen Dateneigenschaft, ohne den Setter aufzurufen.

Zugehörige Lektionen

  • JavaScript · Lektion 17 · Fortgeschritten · Version: 4

Quellen