Metaprogrammierung

Die Objekte Proxy und Reflect ermöglichen es Ihnen, grundlegende Sprachoperationen (z.B. Eigenschaftsabruf, Zuweisung, Enumeration, Funktionsaufruf, etc.) abzufangen und benutzerdefiniertes Verhalten dafür zu definieren. Mit Hilfe dieser beiden Objekte können Sie auf der Metaebene von JavaScript programmieren.

Proxies

Proxy-Objekte ermöglichen es Ihnen, bestimmte Operationen abzufangen und benutzerdefinierte Verhaltensweisen zu implementieren.

Beispielsweise beim Abrufen einer Eigenschaft eines Objekts:

const handler = {
  get(target, name) {
    return name in target ? target[name] : 42;
  },
};

const p = new Proxy({}, handler);
p.a = 1;
console.log(p.a, p.b); // 1, 42

Das Proxy-Objekt definiert ein target (hier ein leeres Objekt) und ein handler-Objekt, in dem eine get-Falle (trap) implementiert ist. Hierdurch wird ein Objekt, das durch einen Proxy gekapselt ist, nicht undefined zurückgeben, wenn undefinierte Eigenschaften abgerufen werden, sondern stattdessen die Zahl 42.

Zusätzliche Beispiele sind auf der Proxy Referenzseite verfügbar.

Terminologie

Die folgenden Begriffe werden verwendet, wenn über die Funktionalität von Proxies gesprochen wird.

handler: Platzhalterobjekt, das Fallen enthält.
Fallen: Die Methoden, die den Zugriff auf Eigenschaften bereitstellen. (Dies ist analog zum Konzept der Fallen in Betriebssystemen.)
Zielobjekt: Objekt, das der Proxy virtualisiert. Es wird häufig als Speicherrückendeckung für den Proxy eingesetzt. Invarianten (nicht veränderbare Semantiken) bezüglich der Nicht-Erweiterbarkeit oder nicht-konfigurierbarer Eigenschaften werden gegen das Zielobjekt überprüft.
Invarianten: Semantiken, die unverändert bleiben, wenn benutzerdefinierte Operationen implementiert werden, werden Invarianten genannt. Wenn Sie die Invarianten eines Handlers verletzen, wird ein TypeError ausgelöst.

Handler und Fallen

Die folgende Tabelle fasst die verfügbaren Fallen zusammen, die für Proxy-Objekte verfügbar sind. Siehe die Referenzseiten für detaillierte Erklärungen und Beispiele.

Handler / Falle	Abfangaktionen
`handler.getPrototypeOf()`	`Object.getPrototypeOf()` `Reflect.getPrototypeOf()` `__proto__` `Object.prototype.isPrototypeOf()` `instanceof`
`handler.setPrototypeOf()`	`Object.setPrototypeOf()` `Reflect.setPrototypeOf()`
`handler.isExtensible()`	`Object.isExtensible()` `Reflect.isExtensible()`
`handler.preventExtensions()`	`Object.preventExtensions()` `Reflect.preventExtensions()`
`handler.getOwnPropertyDescriptor()`	`Object.getOwnPropertyDescriptor()` `Reflect.getOwnPropertyDescriptor()`
`handler.defineProperty()`	`Object.defineProperty()` `Reflect.defineProperty()`
`handler.has()`	Eigenschaftsanfrage `foo in proxy` Vererbte Eigenschaftsanfrage `foo in Object.create(proxy)` `Reflect.has()`
`handler.get()`	Eigenschaftszugriff `proxy[foo]` `proxy.bar` Vererbter Eigenschaftszugriff `Object.create(proxy)[foo]` `Reflect.get()`
`handler.set()`	Eigenschaftszuweisung `proxy[foo] = bar` `proxy.foo = bar` Vererbte Eigenschaftszuweisung `Object.create(proxy)[foo] = bar` `Reflect.set()`
`handler.deleteProperty()`	Eigenschaftslöschung `delete proxy[foo]` `delete proxy.foo` `Reflect.deleteProperty()`
`handler.ownKeys()`	`Object.getOwnPropertyNames()` `Object.getOwnPropertySymbols()` `Object.keys()` `Reflect.ownKeys()`
`handler.apply()`	`proxy(..args)` `Function.prototype.apply()` and `Function.prototype.call()` `Reflect.apply()`
`handler.construct()`	`new proxy(...args)` `Reflect.construct()`

Widerrufbarer `Proxy`

Die Methode Proxy.revocable() wird verwendet, um ein widerrufbares Proxy-Objekt zu erstellen. Dies bedeutet, dass der Proxy über die Funktion revoke widerrufen und ausgeschaltet werden kann.

Danach führt jede Operation auf dem Proxy zu einem TypeError.

const revocable = Proxy.revocable(
  {},
  {
    get(target, name) {
      return `[[${name}]]`;
    },
  },
);
const proxy = revocable.proxy;
console.log(proxy.foo); // "[[foo]]"

revocable.revoke();

console.log(proxy.foo); // TypeError: Cannot perform 'get' on a proxy that has been revoked
proxy.foo = 1; // TypeError: Cannot perform 'set' on a proxy that has been revoked
delete proxy.foo; // TypeError: Cannot perform 'deleteProperty' on a proxy that has been revoked
console.log(typeof proxy); // "object", typeof doesn't trigger any trap

Reflexion

Reflect ist ein eingebautes Objekt, das Methoden für abfangbare JavaScript-Operationen bereitstellt. Die Methoden sind die gleichen wie die der Proxy-Handler.

Reflect ist kein Funktionsobjekt.

Reflect hilft, Standardoperationen vom Handler an das target weiterzuleiten.

Mit Reflect.has() erhalten Sie beispielsweise den in Operator als Funktion:

Reflect.has(Object, "assign"); // true

Eine bessere apply() Funktion

Vor Reflect verwenden Sie in der Regel die Methode Function.prototype.apply(), um eine Funktion mit einem gegebenen this-Wert und arguments, bereitgestellt als Array (oder ein array-ähnliches Objekt), aufzurufen.

Function.prototype.apply.call(Math.floor, undefined, [1.75]);

Mit Reflect.apply wird dies weniger umständlich und leichter verständlich:

Reflect.apply(Math.floor, undefined, [1.75]);
// 1

Reflect.apply(String.fromCharCode, undefined, [104, 101, 108, 108, 111]);
// "hello"

Reflect.apply(RegExp.prototype.exec, /ab/, ["confabulation"]).index;
// 4

Reflect.apply("".charAt, "ponies", [3]);
// "i"

Überprüfen, ob die Eigenschaftsdefinition erfolgreich war

Mit Object.defineProperty, das ein Objekt zurückgibt, wenn erfolgreich, oder andernfalls einen TypeError auslöst, würden Sie einen try...catch Block verwenden, um jeden Fehler abzufangen, der während der Definition einer Eigenschaft aufgetreten ist. Da Reflect.defineProperty() einen booleschen Erfolgsstatus zurückgibt, können Sie hier einfach einen if...else Block verwenden:

if (Reflect.defineProperty(target, property, attributes)) {
  // success
} else {
  // failure
}