ES6 Proxy

概述

Proxy用于修改某些操作的默认行为，等同于在语言层面做出修改，所以属于一种'元编程'，即对编程语言进行编程。Proxy 可以理解成，在目标对象之前架设一层'拦截'，外界对该对象的访问，都必须先通过这层拦截，因此提供了一种机制，可以对外界的访问进行过滤和改写，Proxy 这个次的原意是代理，用在这里表示由它来'代理'某些操作，可以译为'代理器'

    let obj = new Proxy({},{
        set(target, key, receiver){
            console.log(target, key, receiver,'设置属性');
            return Reflect.get(target, key, receiver)  // {} "name" 1 "设置属性"
        },
        get(target, key, value, receiver){
            console.log(target, key, value, receiver,'读取'); // {} "name" Proxy {} undefined "读取"
            return Reflect.set(target, key, value, receiver) 
        }
    })
    obj.name = 1;
    obj.name

上面代码对一个空对象架设了一层拦截，重定义了属性的读取(get)和设置(set)行为。Proxy 实际上重载了'点'运算符，即用自己的定义覆盖了语言的原始定义。

ES6原生提供Proxy构造函数，用来生成Proxy实例。

let proxy = new Proxy(target,handler);

Proxy 对象的所有用法，都是上面这种形式，不同的是handler参数的写法。其中，new Proxy()表示生成一个Proxy实例，target参数表示索要拦截的目标对象，handler参数也是一个对象，用来定制拦截行为。

下面的是一个拦截读取属性的例子

    let proxy = new Proxy({},{
        get(target,property){
            return '读取属性'
        }
    });
    console.log(proxy.name); // 读取属性
    console.log(proxy.time); // 读取属性

上面代码中，Proxy接受两个参数。第一个参数是所要代理的目标对象，即如果没有Proxy的接入，操作原来要访问的就是这个对象；第二个参数是一个配置对象，对于每一个被代理的操作，需要提供一个对应的处理函数，该函数将拦截对应的操作。比如，上面代码中，配置对象有一个get方法，用来拦截对目标对象属性的访问请求。get方法的两个参数分别是目标对象和所要访问的属性

注意：要使Proxy起作用，必须针对Proxy实例进行操作，而不是针对目标对象进行操作

    let obj = {}
    let proxy = new Proxy(obj,{
        get(target,property){
            return '读取属性'
        }
    });
    console.log(proxy.name); // 读取属性
    console.log(obj.time); // undefined

上面代码直接操作目标对象，Proxy拦截不到，所以输出undefined

Proxy 实例也可以作为其他对象的原型对象。

    let proxy = new Proxy({},{
        get(){
            return '111'
        }
    })
    let obj = Object.create(proxy)
    console.log(obj.name); // 111

上面代码中，proxy对象是obj对象的原型，obj对象本身并没有name属性，所以根据原型链，会在proxy对象上读取该属性，导致被拦截

    let handler = {
        get(target, name) {
            if (name === 'prototype') {
                return Object.prototype;
            }
            return 'Hello, ' + name;
        },

        apply(target, thisBinding, args) {
            return args[0];
        },

        construct(target, args) {
            return {value: args[1]};
        }
    };

    let fproxy = new Proxy(function(x, y) {
        return x + y;
    }, handler);

    fproxy(1, 2) // 1
    new fproxy(1, 2) // {value: 2}
    fproxy.prototype === Object.prototype // true
    fproxy.foo === "Hello, foo" // true

对于可以设置，但没有设置拦截的操作，则直接落到目标对象上，按照原先的方式产生结果

下面是 Proxy 支持的拦截操作一览，一共 13 种。

• get(target, propKey, receiver):拦截对象属性的读取，比如proxy.foo和proxy['foo']。
• set(target, propKey, value, receiver):拦截对象属性的设置，比如proxy.foo=1,返回一个布尔值。
• has(target, propKey):拦截propKey in proxy的操作，返回一个布尔值
• deleteProperty(target, propKey)：拦截delete proxy[key]的操作，返回一个布尔值
• ownKeys(target)：拦截Object.getOwnPropertyNames(proxy)、Object.getOwnPropertySymbols(proxy)、Object.keys(proxy)、for...in循环，返回一个数组。该方法返回目标对象所有自身的属性的属性名，而Object.keys()的返回结果仅包括目标对象自身的可便利属性。
• getOwnPropertyDescriptor(target, propKey)：拦截Object.getOwnPropertyDescriptor(proxy, propKey)，返回属性的描述对象。
• defineProperty(target, propKey, propDesc)：拦截Object.defineProperty(proxy, propKey, propDesc）、Object.defineProperties(proxy, propDescs),返回一个布尔值
• preventExtensions(target)：拦截Object.preventExtensions(proxy),返回一个布尔值。
• getPrototypeOf(target)：拦截Object.getPrototypeOf(proxy)，返回一个对象。
• isExtensible(target)：拦截Object.isExtensible(proxy),返回一个布尔值。
• setPrototypeOf(target, proto)：拦截Object.setPrototypeOf(proxy, proto)，返回一个布尔值，如果目标对象是函数，那么还有两种额外操作可以拦截
• apply(target, object, args)：拦截proxy实例作为函数调用的操作，比如proxy(...args)、proxy.call(object, ...args)、proxy.apply(...)
• construct(target, args)：拦截proxy实例作为构造函数调用的操作，比如new proxy()