初步探究ES6之Proxy代理

ES6中提出了一个新的特性，就是proxy，用来拦截在一个对象上的指定操作。这个功能非常的有用。举一个例子来说：

var engineer = { name: 'Joe Sixpack', salary: 50 };var interceptor = {  set: function (receiver, property, value) {    console.log(property, 'is changed to', value);    receiver[property] = value;  }};engineer = Proxy(engineer, interceptor);
1
2
3
4
5
6
7
8
9
10
11

engineer对象被代理Proxy构建的代理对象代替，传入Proxy的第二个参数是一个处理器函数，一个处理器函数有多种方法，如get、set等方法。这里的set方法能够拦截到那些在代理对象身上进行的所有的属性赋值操作。 
当我们执行下面赋值：

engineer.salary = 60;
1

会触发处理器，输出信息：

salary is changed to 60
1

每当代理对象被赋值，处理器函数就会调用，这样就可以用来调试某些问题。

当然了，Proxy可不是仅仅为了调试而诞生的，如果你用过Sencha Touch 或者 AngularJS的话，就会发现这些框架都是类似数据模型绑定的功能。

笔者曾在Sencha Touch中用过代理，代码如下：

            proxy:{//数据代理//              type:'localstorage',//              id:'bills',                // limitParam:'limit',                // pageParam:'page',                //将用户代理改为sql，通过websql来解决localstorage的5MB存储上限的问题                type:'sql',                database:'myDB',                table:'bill',            },            //filters:[{property:"kind",value:"无"}],//过滤属性            listeners:{                removerecords:function(){                    console.log("数据被删除");                },                addrecords:function(){                    console.log("数据被追加");                },                updaterecord:function(){                    console.log("数据被修改");                },            }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

可以看到，它采用的是一种监听setter和getter的办法，而在Angular中采用的则是脏检测。。当我们有了Proxy后，对于简单的数据模型绑定就可以简化这些特定的检测方式了。

我们还可以使用proxy来实现多继承。众所周知，javascript中每个对象只能有一个直接的上层原型，从而无法实现多继承：

var foo = {    foo: function () {        console.log("foo")    }};var bar = {    bar: function () {        console.log("bar")    }};var sonOfFoo = Object.create(foo);sonOfFoo.foo();     //"foo"var sonOfBar = Object.create(bar);sonOfBar.bar();     //"bar"//怎么才能既有foo方法又有bar方法?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

我们可以通过proxy中的get处理器来生成一个继承两个原型的代理对象：

sonOfFooBar = new Proxy({}, {    get: function (target, name) {        return target[name] || foo[name] || bar[name];    }})sonOfFooBar.foo();   //"foo",有foo方法,继承自对象foosonOfFooBar.bar();   //"bar",也有bar方法,继承自对象bar