ES6之路第十一篇：Reflect

概述

Reflect对象与Proxy对象一样，也是 ES6 为了操作对象而提供的新 API。Reflect对象的设计目的有这样几个。

（1）将Object对象的一些明显属于语言内部的方法（比如Object.defineProperty），放到Reflect对象上。现阶段，某些方法同时在Object和Reflect对象上部署，未来的新方法将只部署在Reflect对象上。也就是说，从Reflect对象上可以拿到语言内部的方法。

（2）修改某些Object方法的返回结果，让其变得更合理。比如，Object.defineProperty(obj, name, desc)在无法定义属性时，会抛出一个错误，而Reflect.defineProperty(obj, name, desc)则会返回false。

 1 // 老写法
 2 try {
 3   Object.defineProperty(target, property, attributes);
 4   // success
 5 } catch (e) {
 6   // failure
 7 }
 8 
 9 // 新写法
10 if (Reflect.defineProperty(target, property, attributes)) {
11   // success
12 } else {
13   // failure
14 }

（3）让Object操作都变成函数行为。某些Object操作是命令式，比如name in obj和delete obj[name]，而Reflect.has(obj, name)和Reflect.deleteProperty(obj, name)让它们变成了函数行为。

1 // 老写法
2 'assign' in Object // true
3 
4 // 新写法
5 Reflect.has(Object, 'assign') // true

（4）Reflect对象的方法与Proxy对象的方法一一对应，只要是Proxy对象的方法，就能在Reflect对象上找到对应的方法。这就让Proxy对象可以方便地调用对应的Reflect方法，完成默认行为，作为修改行为的基础。也就是说，不管Proxy怎么修改默认行为，你总可以在Reflect上获取默认行为。

1 Proxy(target, {
2   set: function(target, name, value, receiver) {
3     var success = Reflect.set(target,name, value, receiver);
4     if (success) {
5       log('property ' + name + ' on ' + target + ' set to ' + value);
6     }
7     return success;
8   }
9 });

上面代码中，Proxy方法拦截target对象的属性赋值行为。它采用Reflect.set方法将值赋值给对象的属性，确保完成原有的行为，然后再部署额外的功能。

下面是另一个例子。

 1 var loggedObj = new Proxy(obj, {
 2   get(target, name) {
 3     console.log('get', target, name);
 4     return Reflect.get(target, name);
 5   },
 6   deleteProperty(target, name) {
 7     console.log('delete' + name);
 8     return Reflect.deleteProperty(target, name);
 9   },
10   has(target, name) {
11     console.log('has' + name);
12     return Reflect.has(target, name);
13   }
14 });

上面代码中，每一个Proxy对象的拦截操作（get、delete、has），内部都调用对应的Reflect方法，保证原生行为能够正常执行。添加的工作，就是将每一个操作输出一行日志。

有了Reflect对象以后，很多操作会更易读。

1 // 老写法
2 Function.prototype.apply.call(Math.floor, undefined, [1.75]) // 1
3 
4 // 新写法
5 Reflect.apply(Math.floor, undefined, [1.75]) // 1

静态方法

Reflect对象一共有 13 个静态方法。

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)

上面这些方法的作用，大部分与Object对象的同名方法的作用都是相同的，而且它与Proxy对象的方法是一一对应的。下面是对它们的解释。

Reflect.get(target, name, receiver)

Reflect.get方法查找并返回target对象的name属性，如果没有该属性，则返回undefined。

 1 var myObject = {
 2   foo: 1,
 3   bar: 2,
 4   get baz() {
 5     return this.foo + this.bar;
 6   },
 7 }
 8 
 9 Reflect.get(myObject, 'foo') // 1
10 Reflect.get(myObject, 'bar') // 2
11 Reflect.get(myObject, 'baz') // 3

如果name属性部署了读取函数（getter），则读取函数的this绑定receiver。

 1 var myObject = {
 2   foo: 1,
 3   bar: 2,
 4   get baz() {
 5     return this.foo + this.bar;
 6   },
 7 };
 8 
 9 var myReceiverObject = {
10   foo: 4,
11   bar: 4,
12 };
13 
14 Reflect.get(myObject, 'baz', myReceiverObject) // 8

如果第一个参数不是对象，Reflect.get方法会报错。

1 Reflect.get(1, 'foo') // 报错
2 Reflect.get(false, 'foo') // 报错

Reflect.set(target, name, value, receiver)

Reflect.set方法设置target对象的name属性等于value。

 1 var myObject = {
 2   foo: 1,
 3   set bar(value) {
 4     return this.foo = value;
 5   },
 6 }
 7 
 8 myObject.foo // 1
 9 
10 Reflect.set(myObject, 'foo', 2);
11 myObject.foo // 2
12 
13 Reflect.set(myObject, 'bar', 3)
14 myObject.foo // 3

如果name属性设置了赋值函数，则赋值函数的this绑定receiver。

 1 var myObject = {
 2   foo: 4,
 3   set bar(value) {
 4     return this.foo = value;
 5   },
 6 };
 7 
 8 var myReceiverObject = {
 9   foo: 0,
10 };
11 
12 Reflect.set(myObject, 'bar', 1, myReceiverObject);
13 myObject.foo // 4
14 myReceiverObject.foo // 1

注意，如果 Proxy 对象和 Reflect 对象联合使用，前者拦截赋值操作，后者完成赋值的默认行为，而且传入了receiver，那么Reflect.set会触发Proxy.defineProperty拦截。

 1 let p = {
 2   a: 'a'
 3 };
 4 
 5 let handler = {
 6   set(target, key, value, receiver) {
 7     console.log('set');
 8     Reflect.set(target, key, value, receiver)
 9   },
10   defineProperty(target, key, attribute) {
11     console.log('defineProperty');
12     Reflect.defineProperty(target, key, attribute);
13   }
14 };
15 
16 let obj = new Proxy(p, handler);
17 obj.a = 'A';
18 // set
19 // defineProperty

上面代码中，Proxy.set拦截里面使用了Reflect.set，而且传入了receiver，导致触发Proxy.defineProperty拦截。这是因为Proxy.set的receiver参数总是指向当前的 Proxy 实例（即上例的obj），而Reflect.set一旦传入receiver，就会将属性赋值到receiver上面（即obj），导致触发defineProperty拦截。如果Reflect.set没有传入receiver，那么就不会触发defineProperty拦截。

 1 let p = {
 2   a: 'a'
 3 };
 4 
 5 let handler = {
 6   set(target, key, value, receiver) {
 7     console.log('set');
 8     Reflect.set(target, key, value)
 9   },
10   defineProperty(target, key, attribute) {
11     console.log('defineProperty');
12     Reflect.defineProperty(target, key, attribute);
13   }
14 };
15 
16 let obj = new Proxy(p, handler);
17 obj.a = 'A';
18 // set

如果第一个参数不是对象，Reflect.set会报错。

1 Reflect.set(1, 'foo', {}) // 报错
2 Reflect.set(false, 'foo', {}) // 报错

待续.....