9.1 代理基础

ECMAScript 6新增的代理和反射，为开发者提供了拦截，并向基本操作嵌入额外行为的能力。
具体地说，可以给目标对象定义一个关联的代理对象，而这个代理对象可以作为抽象的目标对象来使用。
在对目标对象的各种操作影响目标对象之前，可以在代理对象中对这些操作加以控制。
9.1.1 创建空代理
最简单的代理是空代理，即除了作为一个抽象的目标对象，什么也不做。
默认情况下，在代理对象上执行的所有操作都会无障碍地传播到目标对象。
因此，在任何可以使用目标对象的地方，都可以通过同样的方式来使用与之关联的代理对象。
代理是使用Proxy构造函数创建的。
这个构造函数接收两个参数：目标对象和处理程序对象。
缺少其中任何一个参数都会抛出TypeError。
要创建空代理，可以传一个简单的对象字面量作为处理程序对象，从而让所有操作畅通无阻地抵达目标对象。
如下面的代码所示，在代理对象上执行的任何操作，实际上都会应用到目标对象。唯一可感知的不同就是代码中操作的是代理对象。

const target = {
  id: 'target'
};
const handler = {};
const proxy = new Proxy(target, handler);
// id属性会访问同一个值
console.log(target.id);     // target
console.log(proxy.id);      // target
// 给目标属性赋值会反映在两个对象上。因为两个对象访问的是同一个值
target.id = 'foo';
console.log(target.id);     // foo
console.log(proxy.id);      // foo
// 给代理属性赋值会反映在这两个对象上。因为这个赋值会转移到目标对象
proxy.id = 'bar';
console.log(target.id);     // bar
console.log(proxy.id);      // bar
// hasOwnProperty()方法在两个地方都会应用到目标对象
console.log(target.hasOwnProperty('id'));  // true
console.log(proxy.hasOwnProperty('id'));   // true
// 因此不能使用instanceof操作符
console.log(target instanceof Proxy);
// Uncaught TypeError: Function has non-object prototype 'undefined' in instanceof check at Function.[Symbol.hasInstance]
console.log(proxy instanceof Proxy);
// Uncaught TypeError: Function has non-object prototype 'undefined' in instanceof check at Function.[Symbol.hasInstance]
// 严格相等可以用来区分代理和目标
console.log(target === proxy);  // false

9.1.2 定义捕获器
使用代理的主要目的是可以定义捕获器（trap）。
捕获器就是在处理程序对象中定义的“基本操作的拦截器”。
每个处理程序对象可以包含零个或多个捕获器，每个捕获器都对应一种基本操作，可以直接或间接在代理对象上调用。
每次在代理对象上调用这些基本操作时，代理可以在这些操作传播到目标对象之前先调用捕获器函数，从而拦截并修改相应的行为。
注：捕获器（trap）是从操作系统中借用的概念。在操作系统中，捕获器是程序流中的一个同步中断，可以暂停程序流，转而执行一段子例程，之后再返回原始程序流。
例如，可以定义一个get()捕获器，在ECMAScript操作以某种形式调用get()时触发。下面的例子定义了一个get()捕获器：

const target = {
  foo: 'bar'
};
const handler = {
  // 捕获器在处理程序对象中以方法名为键
  get() {
    return 'handler override';
  }
};
const proxy = new Proxy(target, handler)

当通过代理对象执行get()操作时，就会触发定义的get()捕获器。
get()不是ECMAScript对象可以调用的方法。这个操作在JavaScript代码中可以通过多种形式触发并被get()捕获器拦截到。proxy[property]、proxy.property或Object.create(proxy)[property]等操作都会触发基本的get()操作以获取属性。
因此所有这些操作只要发生在代理对象上，就会触发get()捕获器。
注意，只有在代理对象上执行这些操作才会触发捕获器。在目标对象上执行这些操作仍然会产生正常的行为。

const target = {
  foo: 'bar'
};
const handler = {
  // 捕获器在处理程序对象中以方法名为键
  get() {
    return 'handler override';
  }
};
const proxy = new Proxy(target, handler)
console.log(target.foo);      // bar
console.log(proxy.foo);       // handler override
console.log(target['foo']);   // bar
console.log(proxy['foo']);    // handler override
console.log(Object.create(target)['foo']); // bar
console.log(Object.create(proxy)['foo']);  // handler override

9.1.3 捕获器参数和反射API
所有捕获器都可以访问相应的参数，基于这些参数可以重建被捕获方法的原始行为。
比如，get()捕获器会接收到目标对象、要查询的属性和代理对象三个参数

const target = {
  foo: 'bar'
};
const handler = {
  get(trapTarget, property, receiver) {
    console.log(trapTarget === target);
    console.log(property);
    console.log(receiver === proxy);
  }
};
const proxy = new Proxy(target, handler)
proxy.foo; 
// true
// foo
// true

有了这些参数，就可以重建被捕获方法的原始行为：

const target = {
  foo: 'bar'
};
const handler = {
  get(trapTarget, property, receiver) {
    return trapTarget[property];
  }
};
const proxy = new Proxy(target, handler)
console.log(proxy.foo);  // bar
console.log(target.foo); // bar

所有捕获器都可以基于自己的参数重建原始操作，但并非所有捕获器行为都像get()那么简单。
因此，通过手动写码如法炮制的想法是不现实的。
实际上，开发者并不需要手动重建原始行为，而是可以通过调用全局Reflect对象上（封装了原始行为）的同名方法来轻松重建。
处理程序对象中所有可以捕获的方法都有对应的反射（Reflect）API方法。
这些方法与捕获器拦截的方法具有相同的名称和函数签名，而且也具有与被拦截方法相同的行为。
因此，使用反射API也可以像下面这样定义出空代理对象：

const target = {
  foo: 'bar'
};
const handler = {
  get() {
    return Reflect.get(...arguments);
  }
};
const proxy = new Proxy(target, handler)
console.log(proxy.foo);  // bar
console.log(target.foo); // bar

甚至可以更简洁：

const target = {
  foo: 'bar'
};
const handler = {
  get: Reflect.get
};
const proxy = new Proxy(target, handler)
console.log(proxy.foo);  // bar
console.log(target.foo); // bar

如果真想创建一个可以捕获所有方法，然后将每个方法转发给对应反射API的空代理，那么甚至不需要定义处理程序对象：

const target = {
  foo: 'bar'
};
const proxy = new Proxy(target, Reflect)  // <== 注意修改的地方
console.log(proxy.foo);  // bar
console.log(target.foo); // bar

反射API为开发者准备好了样板代码，在此基础上开发者可以用最少的代码修改捕获的方法。
比如，下面的代码在某个属性被访问时，会对返回的值进行一番修饰：

const target = {
  foo: 'bar',
  baz: 'qux'
};
const handler = {
  get(trapTarget, property, receiver) {
    let decoration = '';
    if (property === 'foo') {
      decoration = '!!!';
    }
    return Reflect.get(...arguments) + decoration;
  }
}
const proxy = new Proxy(target, handler)
console.log(proxy.foo);  // bar!!!
console.log(target.foo); // bar
console.log(proxy.baz);  // qux
console.log(target.baz); // qux

9.1.4 捕获器不变式
使用捕获器几乎可以改变所有基本方法的行为，但也不是没有限制。
根据ECMAScript规范，每个捕获的方法都知道目标对象上下文、捕获函数签名，而捕获处理程序的行为必须遵循“捕获器不变式”（trap invariant）。
捕获器不变式因方法不同而异，但通常都会防止捕获器定义出现过于反常的行为。
比如，如果目标对象有一个不可配置且不可写的数据属性，那么在捕获器返回一个与该属性不同的值时，会抛出TypeError：

const target = {}
Object.defineProperty(target, 'foo', {
  configurable: false,
  writable: false,
  value: 'bar'
})
const handler = {
  get() {
    return 'qux'
  }
}
const proxy = new Proxy(target, handler)
console.log(proxy.foo);
// Uncaught TypeError: 'get' on proxy: property 'foo' is a read-only and 
// non-configurable data property on the proxy target but the proxy did not 
// return its actual value (expected 'bar' but got 'qux')

9.1.5 可撤销代理
有时候需要中断代理对象与目标对象之间的联系。
对于使用new Proxy()创建的普通代理来说，这种联系会在代理对象的生命周期内一直持续存在。
Proxy也暴露了revocable()方法，这个方法支持撤销代理对象与目标对象的关联。
撤销代理的操作是不可逆的。
而且，撤销函数（revoke()）是幂等的，调用多少次的结果都一样。
撤销代理之后再调用代理会抛出TypeError。
撤销函数和代理对象是在实例化时同时生成的：

const target = {
  foo: 'bar'
};
const handler = {
  get() {
    return 'intercepted'
  }
}
const {proxy, revoke} = Proxy.revocable(target, handler)  //<==注意修改的两处
console.log(proxy.foo);  // intercepted
console.log(target.foo); // bar
revoke();
console.log(proxy.foo);
// Uncaught TypeError: Cannot perform 'get' on a proxy that has been revoked

9.1.6 实用反射API
某些情况下应优先使用反射API，这是有一些理由的。
1．反射API与对象API
在使用反射API时，要记住：
（1）反射API并不限于捕获处理程序；
（2）大多数反射API方法在Object类型上有对应的方法。
通常，Object上的方法适用于通用程序，而反射方法适用于细粒度的对象控制与操作。
2．状态标记
很多反射方法返回称作“状态标记”的布尔值，表示意图执行的操作是否成功。
有时候，状态标记比那些返回修改后的对象或者抛出错误（取决于方法）的反射API方法更有用。
例如，可以使用反射API对下面的代码进行重构：

// 初始代码
const o = {};
try {
  Object.defineProperty(o, 'foo', 'bar');
  console.log('sucess');
} catch(e) {
  console.log('failure');
}

在定义新属性时如果发生问题，Reflect.defineProperty()会返回false，而不是抛出错误。
因此使用这个反射方法可以这样重构上面的代码：

const o = {};
if (Reflect.defineProperty(o, 'foo', {value: 'bar'})) {
  console.log('success');
} else {
  console.log('failure');
}

以下反射方法都会提供状态标记：
❑ Reflect.defineProperty()
❑ Reflect.preventExtensions()
❑ Reflect.setPrototypeOf()
❑ Reflect.set()
❑ Reflect.deleteProperty()
3．用一等函数替代操作符
以下反射方法提供只有通过操作符才能完成的操作:
❑ Reflect.get()：可以替代对象属性访问操作符。
❑ Reflect.set()：可以替代=赋值操作符。
❑ Reflect.has()：可以替代in操作符或with()。
❑ Reflect.deleteProperty()：可以替代delete操作符。
❑ Reflect.construct()：可以替代new操作符。
4．安全地应用函数
在通过apply方法调用函数时，被调用的函数可能也定义了自己的apply属性（虽然可能性极小）。
为绕过这个问题，可以使用定义在Function原型上的apply方法，
比如：

Function.prototype.apply.call(myFunc, thisVal, argumentList);

这种可怕的代码完全可以使用Reflect.apply来避免：

Reflect.apply(myFunc, argumentList);

9.1.7 代理另一个代理
代理可以拦截反射API的操作，而这意味着完全可以创建一个代理，通过它去代理另一个代理。
这样就可以在一个目标对象之上构建多层拦截网：

const target = {
  foo: 'bar'
};
const firstProxy = new Proxy(target, {
  get() {
    console.log('first proxy');
    return Reflect.get(...arguments);
  }
});
const secondProxy = new Proxy(firstProxy, {
  get() {
    console.log('second Proxy');
    return Reflect.get(...arguments);
  }
});
console.log(secondProxy.foo);
// second Proxy
// first proxy
// bar

9.1.8 代理的问题与不足
1．代理中的this
代理潜在的一个问题来源是this值。方法中的this通常指向调用这个方法的对象：
2．代理与内部槽位
代理与内置引用类型（比如Array）的实例通常可以很好地协同，但有些ECMAScript内置类型可能会依赖代理无法控制的机制，结果导致在代理上调用某些方法会出错。