Viewing: developer.mozilla.org

Proxy

Proxy

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

let p = new Proxy({}, handler);
p.a = 1;

console.log(p.a, p.b); // 1, 42

Proxy target get handler undefined 42

Proxy

handler

target: JavaScript
: TypeError

Proxy

/
`handler.getPrototypeOf()`	`Object.getPrototypeOf()` `Reflect.getPrototypeOf()` `__proto__` `Object.prototype.isPrototypeOf()` `instanceof`	`getPrototypeOf` `null` `target` `Object.getPrototypeOf(proxy)` `Object.getPrototypeOf(target)`
`handler.setPrototypeOf()`	`Object.setPrototypeOf()` `Reflect.setPrototypeOf()`	`target` `prototype` `Object.getPrototypeOf(target)`
`handler.isExtensible()`	`Object.isExtensible()` `Reflect.isExtensible()`	`Object.isExtensible(proxy)` `Object.isExtensible(target)`
`handler.preventExtensions()`	`Object.preventExtensions()` `Reflect.preventExtensions()`	`Object.isExtensible(proxy)` `false` `Object.preventExtensions(proxy)` `true`
`handler.getOwnPropertyDescriptor()`	`Object.getOwnPropertyDescriptor()` `Reflect.getOwnPropertyDescriptor()`	`getOwnPropertyDescriptor` `undefined` `target` `target` `target` `target` `target` `target` `target` `Object.getOwnPropertyDescriptor(target)` `Object.defineProperty` `target`
`handler.defineProperty()`	`Object.defineProperty()` `Reflect.defineProperty()`	`target` `target` `target` `target` `Object.defineProperty(target, prop, descriptor)` `defineProperty` `false` `TypeError`
`handler.has()`	`foo in proxy` `foo in Object.create(proxy)` `Reflect.has()`	`target` `target` `target`
`handler.get()`	`proxy[foo]` `proxy.bar` `Object.create(proxy)[foo]` `Reflect.get()`	`target` `target` `[[Get]]` `undefined` `undefined`
`handler.set()`	`proxy[foo] = bar` `proxy.foo = bar` `Object.create(proxy)[foo] = bar` `Reflect.set()`	`target` `target` `target` `[[Set]]` `undefined` `set` `false` `TypeError`
`handler.deleteProperty()`	`delete proxy[foo]` `delete proxy.foo` `Reflect.deleteProperty()`	`target`
`handler.ownKeys()`	`Object.getOwnPropertyNames()` `Object.getOwnPropertySymbols()` `Object.keys()` `Reflect.ownKeys()`	`ownKeys` `String` `Symbol` `target` `target` `target`
`handler.apply()`	`proxy(..args)` `Function.prototype.apply()` `Function.prototype.call()` `Reflect.apply()`	`handler.apply`
`handler.construct()`	`new proxy(...args)` `Reflect.construct()`	`Object`

`Proxy`

Proxy.revocable() Proxy revoke

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`

Reflect JavaScript

Reflect

Reflect target

Reflect.has() in

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

`apply`

Reflect Function.prototype.apply() this arguments

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

Reflect.apply

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"

Object.defineProperty TypeError try...catch Reflect.defineProperty if...else

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

MDN

2026526 MDN

GitHub