Meta programming - JavaScript

handler: Placeholder object which contains traps.
traps: The methods that provide property access. (This is analogous to the concept of traps in operating systems.)
target: Object which the proxy virtualizes. It is often used as storage backend for the proxy. Invariants (semantics that remain unchanged) regarding object non-extensibility or non-configurable properties are verified against the target.
invariants: Semantics that remain unchanged when implementing custom operations are called invariants. If you violate the invariants of a handler, a TypeError will be thrown.

Handlers and traps

The following table summarizes the available traps available to Proxy objects. See the reference pages for detailed explanations and examples.

Handler / trap	Interceptions
`handler.getPrototypeOf()`	`Object.prototype.isPrototypeOf()` `instanceof`
`handler.setPrototypeOf()`	`Reflect.setPrototypeOf()`
`handler.isExtensible()`	`Reflect.isExtensible()`
`handler.preventExtensions()`	`Reflect.preventExtensions()`
`handler.getOwnPropertyDescriptor()`	`Reflect.getOwnPropertyDescriptor()`
`handler.defineProperty()`	`Reflect.defineProperty()`
`handler.has()`	Property query `foo in proxy` Inherited property query `foo in Object.create(proxy)` `Reflect.has()`
`handler.get()`	Property access `proxy[foo]` `proxy.bar` Inherited property access `Object.create(proxy)[foo]` `Reflect.get()`
`handler.set()`	Property assignment `proxy[foo] = bar` `proxy.foo = bar` Inherited property assignment `Object.create(proxy)[foo] = bar` `Reflect.set()`
`handler.deleteProperty()`	Property deletion `delete proxy[foo]` `delete proxy.foo` `Reflect.deleteProperty()`
`handler.ownKeys()`	`Reflect.ownKeys()`
`handler.apply()`	`proxy(..args)` `Function.prototype.apply()` and `Reflect.apply()`
`handler.construct()`	`new proxy(...args)` `Reflect.construct()`

Revocable `Proxy`

The Proxy.revocable() method is used to create a revocable Proxy object. This means that the proxy can be revoked via the function revoke and switches the proxy off.

Afterwards, any operation on the proxy leads to a 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

Reflection

proxy handler's.

Reflect is not a function object.

Reflect helps with forwarding default operations from the handler to the target.

With in operator as a function:

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

A better apply() function

Before Reflect, you typically use the array-like object).

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

With Reflect.apply this becomes less verbose and easier to understand:

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"

Checking if property definition has been successful

With Reflect.defineProperty() returns a Boolean success status, you can just use an if...else block here:

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