12,13 Proxy和Reflect

Proxy和Reflect

Proxy(代理)

Proxy用于修改某些操作的默认行为，等同于在语言层面做出修改，所以属于一种“元编程”（meta programming），即对编程语言进行编程。

Proxy可以理解成，在目标对象之前架设一层“拦截”，外界对该对象的访问，都必须先通过这层拦截，因此提供了一种机制，可以对外界的访问进行过滤和改写。Proxy这个词的原意是代理，用在这里表示由它来“代理”某些操作，可以译为“代理器”。

能够拦截一些默认操作.

1. get(target, propKey, receiver)

2. set(target, propKey, value, receiver)

3. has(target, propKey)

4. deleteProperty(target, propKey)

5. ownKeys(target)

6. getOwnPropertyDescriptor(target, propKey)

7. defineProperty(target, propKey, propDesc)

8. preventExtensions(target)

9. getPrototypeOf(target)

10. isExtensible(target)

11. setPrototypeOf(target, proto)

12. apply(target, object, args)

13. construct(target, args)

    ​

也就是说你可以改变这些操作.

var obj = new Proxy({}, {
  get: function (target, key, receiver) {
    alert(`getting ${key}!`);
    return Reflect.get(target, key, receiver);
  },
  set: function (target, key, value, receiver) {
    alert(`setting ${key}!`);
    return Reflect.set(target, key, value, receiver);
  }
});

obj.count = 1
//  setting count!
++obj.count
//  getting count!
//  setting count!
//  2

你可以返回你想返回的.

或者只是像上面代码一样做些记录.

var proxy = new Proxy(target, handler);

格式是这样的.

所以你可以这样用.

在先创建了 Proxy 以后.

var proxy = new Proxy(target, handler);

给 原型链 赋值,或者使用 Object.create。

就可以在 函数中使用 Proxy

var o = new Proxy({},{ get:function()  { return 30 } });
var o3 = Object.create(o)
o3.aa //30

设下就看你 get 里面怎么拦截.

剩下来说

就是看你想拦截谁.

Reflect(反射)

也就是上面代码的

Reflect.set(target, key, value, receiver);

1. 将Object对象的一些明显属于语言内部的方法（比如Object.defineProperty），放到Reflect对象上。现阶段，某些方法同时在Object和Reflect对象上部署，未来的新方法将只部署在Reflect对象上。
2. 修改某些Object方法的返回结果，让其变得更合理。比如，Object.defineProperty(obj, name, desc)在无法定义属性时，会抛出一个错误，而Reflect.defineProperty(obj, name, desc)则会返回false。
3. 让Object操作都变成函数行为。某些Object操作是命令式，比如name in obj和delete obj[name]，而Reflect.has(obj, name)和Reflect.deleteProperty(obj, name)让它们变成了函数行为。
4. Reflect对象的方法与Proxy对象的方法一一对应，只要是Proxy对象的方法，就能在Reflect对象上找到对应的方法。这就让Proxy对象可以方便地调用对应的Reflect方法，完成默认行为，作为修改行为的基础。也就是说，不管Proxy怎么修改默认行为，你总可以在Reflect上获取默认行为。

也就是说,其实 Reflect 并不是一个一定需要存在的方法.

他更多的是出于语义,写法上的考虑应运而生的东西.

设计更合理,返回值更合理.

总共有以下的方法

• Reflect.apply(target,thisArg,args)
• Reflect.construct(target,args)
• Reflect.get(target,name,receiver)
• Reflect.set(target,name,value,receiver)
• Reflect.defineProperty(target,name,desc)
• Reflect.deleteProperty(target,name)
• Reflect.has(target,name)
• Reflect.ownKeys(target)
• Reflect.isExtensible(target)
• Reflect.preventExtensions(target)
• Reflect.getOwnPropertyDescriptor(target, name)
• Reflect.getPrototypeOf(target)
• Reflect.setPrototypeOf(target, prototype)