(1)Proxy的概述
Proxy用于修改某些操作的默认行为，可以理解成，在目标对象之前架设一层"拦截"，外界对
该对象的访问，必须先通过这层拦截，因此提供了一种机制，可以对外界的访问进行过滤和
改写。Proxy在这里可以译为代理器。ES6提供Proxy构造函数，用来生成Proxy实例。
用法：var proxy = new Proxy(target, handler);
说明：Proxy对象的所有用法，都是这种形式，不同的只是handler参数的写法；
1.new Proxy()表示生成一个Proxy实例；
2.target参数表示所要拦截的目标对象；
3.handler参数也是一个对象，用来定制拦截行为；
下面是一个例子：
var proxy = new Proxy({}, {
get: function(target, property) {
return 35;
}
});
proxy.time // 35
proxy.name // 35
proxy.title // 35
说明：Proxy接受两个参数。第一个参数是所要代理的目标对象（上例是一个空对象），即如果没有Proxy的介入，操作原来要访问的就是这个对象；第二个参数是一个配置对象，对于每一个被代理的操作，需要提供一个对应的处理函数，该函数将拦截对应的操作。比如，上面代码中，配置对象有一个get方法，用来拦截对目标对象属性的访问请求。
get方法的两个参数分别是目标对象和所要访问的属性。
特别说明的是：1.要使得Proxy起作用，必须针对必须针对Proxy实例（上例是proxy对象）进行操作，
而不是针对目标对象（上例是空对象）进行操作。
2.如果handler没有设置任何拦截，那就等同于直接通向原对象。
3.要想在object对象上调用，Proxy都起作用，有两个方法：
a.一个技巧是将 Proxy 对象，设置到object.proxy属性，从而可以在object对象上调用。
var object = { proxy: new Proxy(target, handler) };
b.
roxy 实例也可以作为其他对象的原型对象。
var proxy = new Proxy({}, {
get: function(target, property) {
return 35;
}
});
let obj = Object.create(proxy);
obj.time // 35
上面代码中，proxy对象是obj对象的原型，obj对象本身并没有time属性，所以根据原型链，会在proxy对象上读取该属性，导致被拦截。
4.同一个拦截器函数，可以设置拦截多个操作
Proxy支持的拦截操作一共有13种，下面分别介绍
（2）get()--用于某个属性的读取操作
参数：有三个，依次为目标对象、属性名和 proxy 实例本身（严格地说，是操作行为所针对的对象），其中最后一个参数可选。
第三个参数总是指向原始的读操作所在的那个对象
get方法可以继承，
let proto = new Proxy({}, {
get(target, propertyKey, receiver) {
console.log('GET ' + propertyKey);
return target[propertyKey];
}
});
let obj = Object.create(proto);
obj.foo // "GET foo"
上面代码中，拦截操作定义在Prototype对象上面，所以如果读取obj对象继承的属性时，拦截会生效。
const proxy = new Proxy({}, {
get: function(target, property, receiver) {
return receiver;
}
});
const d = Object.create(proxy);
d.a === d // true
上面代码中，d对象本身没有a属性，所以读取d.a的时候，会去d的原型proxy对象找。这时，receiver就指向d，代表原始的读操作所在的那个对象。
注意：
如果一个属性不可配置（configurable）且不可写（writable），则 Proxy 不能修改该属性，否则通过 Proxy 对象访问该属性会报错。（3）set()--用于拦截某个属性的赋值操作
参数：可以接受四个参数，依次为目标对象、属性名、属性值和 Proxy 实例本身，其中最后一个参数可选。
第四个参数，指的是原始的操作行为所在的那个对象，一般情况下是proxy实例本身
下面是个例子：
const handler = {
set: function(obj, prop, value, receiver) {
obj[prop] = receiver;
}
};
const proxy = new Proxy({}, handler);
const myObj = {};
Object.setPrototypeOf(myObj, proxy);
myObj.foo = 'bar';
myObj.foo === myObj // true
上面代码中，设置myObj.foo属性的值时，myObj并没有foo属性，因此引擎会到myObj的原型链去找foo属性。myObj的原型对象proxy是一个 Proxy 实例，设置它的foo属性会触发set方法。这时，第四个参数receiver就指向原始赋值行为所在的对象myObj。
注意：1.如果目标对象自身的某个属性，不可写且不可配置，那么set方法将不起作用。
2.严格模式下，set代理如果没有返回true，就会报错。
'use strict';
const handler = {
set: function(obj, prop, value, receiver) {
obj[prop] = receiver;
// 无论有没有下面这一行，都会报错
return false;
}
};
const proxy = new Proxy({}, handler);
proxy.foo = 'bar';
// TypeError: 'set' on proxy: trap returned falsish for property 'foo'（3）apply()--用于拦截函数的调用、call和apply操作
参数：接受三个参数，分别是目标对象、目标对象的上下文对象（this）和目标对象的参数数组。
下面是一个例子。
var target = function () { return 'I am the target'; };
var handler = {
apply: function () {
return 'I am the proxy';
}
};
var p = new Proxy(target, handler);
p()
// "I am the proxy"
上面代码中，变量p是 Proxy 的实例，当它作为函数调用时（p()），就会被apply方法拦截，返回一个字符串。
注意：直接调用Reflect.apply方法，也会被拦截。
（4）has()--用来拦截HasProperty操作，即判断对象是否具有某个属性时，这个方法会生效。典型的操作就是in运算符
参数：接受两个参数，分别是目标对象、需查询的属性名。
注意：1.如果原对象不可配置或者禁止扩展，这时has拦截会报错。
2.has方法拦截的是HasProperty操作，而不是HasOwnProperty操作，即has方法不判断一个属性是对象自身的属性，还是继承的属性
3.虽然for...in循环也用到了in运算符，但是has拦截对for...in循环不生效
下面是个例子：
var handler = {
has (target, key) {
if (key[0] === '_') {
return false;
}
return key in target;
}
};
var target = { _prop: 'foo', prop: 'foo' };
var proxy = new Proxy(target, handler);
'_prop' in proxy // false
上面代码中，如果原对象的属性名的第一个字符是下划线，proxy.has就会返回false，从而不会被in运算符发现。（5）construct--拦截new命令
参数：接受3个参数，
target：目标对象
args：构造函数的参数对象
newTarget：创造实例对象时，new命令作用的构造函数（下面例子的p）
例子：
var p = new Proxy(function () {}, {
construct: function(target, args) {
console.log('called: ' + args.join(', '));
return { value: args[0] * 10 };
}
});
(new p(1)).value
// "called: 1"
注意：construct方法返回的必须是一个对象，否则报错。（6）deleteProperty()--用于拦截delete操作，如果这个方法抛出错误或返回false
当前属性就无法被delete命令删除。
参数：接受两个参数，第一个参数是目标对象，第二个参数是要删除的属性
注意：目标对象自身的不可配置（configurable）的属性，不能被deleteProperty方法删除，否则报错。
下面是一个例子：
var handler = {
deleteProperty (target, key) {
invariant(key, 'delete');
delete target[key];
return true;
}
};
function invariant (key, action) {
if (key[0] === '_') {
throw new Error(`Invalid attempt to ${action} private "${key}" property`);
}
}
var target = { _prop: 'foo' };
var proxy = new Proxy(target, handler);
delete proxy._prop
// Error: Invalid attempt to delete private "_prop" property
上面代码中，deleteProperty方法拦截了delete操作符，删除第一个字符为下划线的属性会报错。
（7）defineProperty()--用于拦截Object.defineProperty操作
参数：接受3个参数，第一个参数是目标对象，第二个参数是属性，第三个是属性描述
注意:1.如果目标对象不可扩展（non-extensible），则defineProperty不能增加目标对象上不存在的属性，否则会报错。另外，
2.如果目标对象的某个属性不可写（writable）或不可配置（configurable），则defineProperty方法不得改变这两个设置。下面是例子：
defineProperty方法拦截了Object.defineProperty操作。
var handler = {
defineProperty (target, key, descriptor) {
return false;
}
};
var target = {};
var proxy = new Proxy(target, handler);
proxy.foo = 'bar' // 不会生效
（8）getOwnPropertyDescriptor()--拦截Object.getOwnPropertyDescriptor()，返回一个属性描述对象或者undefined。
（9）getPrototypeOf()--拦截获取对象原型。
参数：目标对象
拦截的操作有：
Object.prototype.__proto__
Object.prototype.isPrototypeOf()
Object.getPrototypeOf()
Reflect.getPrototypeOf()
instanceof
注意：getPrototypeOf方法的返回值必须是对象或者null，否则报错。另外，如果目标对象不可扩展（non-extensible）， getPrototypeOf方法必须返回目标对象的原型对象。
下面是例子：
var proto = {};
var p = new Proxy({}, {
getPrototypeOf(target) {
return proto;
}
});
Object.getPrototypeOf(p) === proto // true
上面代码中，getPrototypeOf方法拦截Object.getPrototypeOf()，返回proto对象。
（10）isExtensible()--用于拦截Object.isExtensible操作。
参数：该方法的参数是目标对象
注意：1。该方法只能返回布尔值，否则返回值会被自动转为布尔值。
2.这个方法有一个强限制，它的返回值必须与目标对象的isExtensible属性保持一致，
否则就会抛出错误。
Object.isExtensible(proxy) === Object.isExtensible(target)
（11）ownKeys() --用来拦截对象自身属性的读取问题
参数;目标对象
拦截以下操作：
Object.getOwnPropertyNames()
Object.getOwnPropertySymbols()
Object.keys()
for...in循环
注意：1.使用该方法时，有三类属性会被自动过滤，不会返回
目标对象上不存在的属性
属性名为 Symbol 值
不可遍历（enumerable）的属性2.该方法返回的数组成员，只能是字符串或 Symbol 值。如果有其他类型的值，
或者返回的根本不是数组，就会报错。
3.如果目标对象自身包含不可配置的属性，则该属性必须被ownKeys方法返回，否则报错。
4.如果目标对象是不可扩展的（non-extensible），这时ownKeys方法返回的数组之中，必须包含原对象的所有属性，
且不能包含多余的属性，否则报错。
这是一个例子：
let target = {
a: 1,
b: 2,
c: 3
};
let handler = {
ownKeys(target) {
return ['a'];
}
};
let proxy = new Proxy(target, handler);
Object.keys(proxy)
// [ 'a' ]
（12）preventExtensions()--拦截Object.preventExtensions()
参数：目标对象
注意：1.该方法必须返回一个布尔值，否则会被自动转为布尔值。
2.只有目标对象不可扩展时（即Object.isExtensible(proxy)为false），proxy.preventExtensions才能返回true，否则会报错。
（13）setPrototypeOf()--主要用来拦截Object.setPrototypeOf方法。
参数：目标对象、属性
注意：1.该方法只能返回布尔值，否则会被自动转为布尔值。
2.如果目标对象不可扩展（non-extensible），setPrototypeOf方法不得改变目标对象的原型。
下面是一个例子。
var handler = {
setPrototypeOf (target, proto) {
throw new Error('Changing the prototype is forbidden');
}
};
var proto = {};
var target = function () {};
var proxy = new Proxy(target, handler);
Object.setPrototypeOf(proxy, proto);
// Error: Changing the prototype is forbidden
上面代码中，只要修改target的原型对象，就会报错。
（14）Proxy.revocable()返回一个可取消的 Proxy 实例。
例子：let target = {};
let handler = {};
let {proxy, revoke} = Proxy.revocable(target, handler);
proxy.foo = 123;
proxy.foo // 123
revoke();
proxy.foo // TypeError: Revoked
Proxy.revocable方法返回一个对象，该对象的proxy属性是Proxy实例，revoke属性是一个函数，可以取消Proxy实例。上面代码中，当执行revoke函数之后，再访问Proxy实例，就会抛出一个错误。
Proxy.revocable的一个使用场景是，目标对象不允许直接访问，必须通过代理访问，一旦访问结束，就收回代理权，不允许再次访问。（15）this问题
虽然 Proxy 可以代理针对目标对象的访问，但它不是目标对象的透明代理，即不做任何拦截的情况下，也无法保证与目标对象的行为一致。主要原因就是在 Proxy 代理的情况下，目标对象内部的this关键字会指向 Proxy 代理。
const target = {
m: function () {
console.log(this === proxy);
}
};
const handler = {};
const proxy = new Proxy(target, handler);
target.m() // false
proxy.m() // true
上面代码中，一旦proxy代理target.m，后者内部的this就是指向proxy，而不是target。
由于this指向的变化，导致 Proxy 无法代理目标对象。
（16）实例：web服务的客户端