Reflect.set() — Methode · JavaScript-Referenz

Signatur

Reflect.set(target, propertyKey, value, receiver)

Beschreibung

Reflect.set() ist das funktionale Gegenstück zur Zuweisung target[propertyKey] = value. Die Methode führt die interne Operation [[Set]] aus: Existiert auf dem Objekt oder in seiner Prototypenkette ein Setter, wird er aufgerufen; andernfalls wird eine eigene Dateneigenschaft angelegt oder überschrieben.

Der wichtigste Unterschied zur normalen Zuweisung: Reflect.set() gibt immer einen booleschen Wert zurück. Schlägt das Setzen fehl (z. B. bei nicht beschreibbaren Eigenschaften, eingefrorenen Objekten oder fehlendem Setter), erhält man false – auch im Strict Mode, wo eine normale Zuweisung einen TypeError werfen würde. Dadurch lässt sich Erfolg ohne try...catch prüfen.

Besonders nützlich ist Reflect.set() in Proxy-Handlern: In der set-Falle leitet man die Operation mit Reflect.set(target, key, value, receiver) an das Originalobjekt weiter und gibt deren Ergebnis direkt zurück. Über den optionalen Parameter receiver steuert man, welcher Wert in einem Setter als this dient und auf welchem Objekt eine neue Eigenschaft angelegt wird.

Parameter

Name	Typ	Default	Beschreibung
$target Pflicht	object		Das Zielobjekt, auf dem die Eigenschaft gesetzt werden soll. Ist es kein Objekt, wird ein `TypeError` geworfen.
$propertyKey Pflicht	string \| symbol		Name oder Symbol der zu setzenden Eigenschaft. Andere Werte werden in einen String umgewandelt.
$value Pflicht	any		Der Wert, der zugewiesen werden soll.
$receiver	any	target	Der Wert, der bei einem Setter als `this` verwendet wird und auf dem eine neue Dateneigenschaft angelegt wird. Standardmäßig `target`.

Rückgabewert

Typ

boolean

Beschreibung

true, wenn die Eigenschaft erfolgreich gesetzt wurde, sonst false.

Beispiele

Grundlegende Verwendung und Erfolgsprüfung

const config = { theme: 'light' };

console.log(Reflect.set(config, 'theme', 'dark')); // true
console.log(config.theme);

// Arrays: Index und length setzen
const list = ['a', 'b', 'c'];
Reflect.set(list, 2, 'z');
Reflect.set(list, 'length', 2);
console.log(list);

true dark ['a', 'b']

Fehlschlag ohne Exception bei eingefrorenen Objekten

'use strict';

const frozen = Object.freeze({ version: 1 });

// frozen.version = 2; // würde im Strict Mode einen TypeError werfen
const ok = Reflect.set(frozen, 'version', 2);
console.log(ok, frozen.version);

const readOnly = {};
Object.defineProperty(readOnly, 'id', { value: 42, writable: false });
console.log(Reflect.set(readOnly, 'id', 7));

false 1 false

Validierender Proxy mit Weiterleitung

const user = { name: 'Anna', age: 30 };

const validated = new Proxy(user, {
  set(target, key, value, receiver) {
    if (key === 'age' && (!Number.isInteger(value) || value < 0)) {
      console.warn(`Ungültiges Alter: ${value}`);
      return false; // im Strict Mode: TypeError beim Aufrufer
    }
    // Standardverhalten inkl. Setter und receiver beibehalten
    return Reflect.set(target, key, value, receiver);
  }
});

validated.age = 31;
console.log(user.age);
console.log(Reflect.set(validated, 'age', -5));

31 Ungültiges Alter: -5 false

Setter mit abweichendem receiver aufrufen

const temperature = {
  _celsius: 0,
  set fahrenheit(f) {
    this._celsius = Math.round((f - 32) * 5 / 9);
  }
};

const sensor = { _celsius: null };

// Setter von temperature, aber this === sensor
Reflect.set(temperature, 'fahrenheit', 212, sensor);
console.log(sensor._celsius, temperature._celsius);

100 0

// Wichtig · Fallstricke

Kein Objekt als Ziel: Ist target ein primitiver Wert (z. B. Reflect.set(1, 'x', 2)), wird ein TypeError geworfen – anders als bei der Zuweisung (1).x = 2, die im Sloppy Mode einfach nichts bewirkt.
Rückgabewert prüfen: false wird still zurückgegeben. Wer den Wert ignoriert, übersieht fehlgeschlagene Zuweisungen leicht.
receiver in Proxy-Fallen weitergeben: Lässt man receiver in der set-Falle weg, zeigt this in Settern auf das Originalobjekt statt auf den Proxy bzw. ein erbendes Objekt – das führt bei Vererbung zu subtilen Fehlern.
Ist receiver kein Objekt oder besitzt er eine nicht beschreibbare bzw. Accessor-Eigenschaft gleichen Namens, liefert die Methode false.
Kompatibilität: In allen modernen Browsern und Node.js 6+ verfügbar; nicht im Internet Explorer.

Siehe auch

Reflect Reflect.get() Reflect.has() Proxy Object.freeze()