Metaprogrammierung

Die Objekte Proxy und Reflect ermöglichen es Ihnen, fundamentale Sprachoperationen (z. B. Eigenschaftenabfrage, Zuweisung, Aufzählung, Funktionsaufruf usw.) abzufangen und benutzerdefinierte Verhaltensweisen zu definieren. Mit Hilfe dieser beiden Objekte sind Sie in der Lage, auf der Metaebene von JavaScript zu programmieren.

Proxies

Proxy-Objekte erlauben es Ihnen, bestimmte Operationen abzufangen und benutzerdefinierte Verhaltensweisen zu implementieren.

Zum Beispiel 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. Hierbei wird ein proxied Objekt nicht undefined zurückgeben, wenn undefinierte Eigenschaften abgefragt 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 (traps): Die Methoden, die den Zugriff auf Eigenschaften bereitstellen. (Dies ist analog zum Konzept der Fallen in Betriebssystemen.)
Ziel (target): Objekt, das vom Proxy virtualisiert wird. Es wird häufig als Speicherungshintergrund für den Proxy verwendet. Invarianten (Semantiken, die unverändert bleiben) in Bezug auf die Nichterweiterbarkeit von Objekten oder nicht konfigurierbare Eigenschaften werden gegen das Ziel verifiziert.
Invarianten: Semantiken, die bei der Implementierung benutzerdefinierter Operationen unverändert bleiben, werden als Invarianten bezeichnet. 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	Abfangvorgänge
`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()`	Eigenschaftsabfrage `foo in proxy` Vererbte Eigenschaftsabfrage `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()`	Eigenschafts-Löschung `delete`