定义
- Reflect是Metaprogramming思想的一种实现，关于Metaprogramming，维基百科上是这样定义的:
Metaprogramming is a programming technique in which computer programs have the ability to treat other programs as their data. It means that a program can be designed to read, generate, analyze or transform other programs, and even modify itself while running.
- 简单来说就是可以使用其他程序来作为输入数据的一种编程技术
MDN上面关于Reflect的描述很清晰:
Unlike most global objects,
Reflectis not a constructor. You cannot use it with anewoperatoror invoke theReflectobject as a function. All properties and methods ofReflectare static (just like theMathobject).
Reflect中主要有三个概念：
- Introspection: Code is able to inspect itself.
- Self-Modification: As the name suggests, code is able to modify itself.
- Intercession: Acting behalf of somebody else. This can be achieve by wrapping, trapping, intercepting.
Reflect是通过Introspection来实现反射，主要用于获取底层原生的方法，类似的Introspection方法有：
- Object.keys:返回一个可以通过object直接访问的可迭代字符串元素的数组
- Object.getOwnPropertyNames: 返回一个包含所有属性名数组
支持的方法
Reflect的优点
统一的命名空间
JavaScript 已经有API支持reflection对象，但是这些API都没有很好地组织起来，所以ES6中的Reflect优化了命名空间。不像其他的全局对象，
用法简单
Reflect不是一个constructor，不能使用new操作符或像一个function一样调用，所有Reflect的属性和方法都是静态的，使用方法和Math对象一样。
Object上面的Introspection方法不能完成操作的时候会抛出异常，处理这些异常会增加programmer的负担，所以可以使用boolean(true | false)来替代异常处理。
例如：
- 使用Object.defineProperty的情况
try {
Object.defineProperty(obj, name, desc);
// property defined successfully
} catch (e) {
// possible failure and need to do something about it
}
- 使用Reflect的情况
if (Reflect.defineProperty(obj, name, desc)) {
// success
} else {
// failure (and far better)
}
First-Class 操作体验
在ES5中，你可以使用prop in obj来判断一个对象中是否存在某个属性，如果想多次使用的话，还需要把这些操作放到一个函数中才可以传递一个first-class value。但是在ES6中，Reflect API 就是 first-class function的一部分， Reflect.has(obj, prop) 就等于prop in obj
在apply函数中的可读性
在ES5 中，调用一个func 的方式有：
Function.prototype.apply.call(func, obj, arr);
简单版：
func.apply(obj, arr);
当然，上面这种简单版也可能存在潜在问题，因为func可能是一个已有自定apply的对象
在ES6中，我们可以有更优雅及更具可读性的方式：
Reflect.apply(func, obj, arr);
解决Proxy操作后对象中需要访问原生方法的问题
当使用Proxy去包裹一个对象时，可以自定义其默认方法，但是如果想调用此对象的原生方法时，此时直接通过访问对象来调用是获取不到原生方法的，所以此时需要使用Reflect来解决这个问题。
例如：
const employee = {
firstName: 'Hal',
lastName: 'Shaw'
};
let logHandler = {
get: function(target, fieldName) {
console.log(target[fieldName]);
return Reflect.get(target, fieldName);
}
};
let func = () => {
let p = new Proxy(employee, logHandler);
p.firstName;
p.lastName;
p.testname;
p.name;
};
func();
在上面例子中，复写了get方法来打印属性的值，一旦打印完毕，就使用Reflect API来返回原生的get方法来取值。
输出结果如下：
Hal
Shaw
undefined
undefined
好像很普通的样子，但是我们可以自己改写下就可以看到其中的原理了，如下：
const employee = {
firstName: 'Hal',
lastName: 'Shaw'
};
let logHandler = {
get: function(target, fieldName) {
if(!target[fieldName]) {
console.log("Default name ")
}
else
console.log("Proxy: " + target[fieldName]);
return Reflect.get(target, fieldName);
}
};
let func = () => {
let p = new Proxy(employee, logHandler);
p.firstName;
p.lastName;
p.testname;
p.name;
};
func();
输出结果如下：
Proxy: Hal
Proxy: Shaw
Default name
Default name
此时，我们如果单独new一个Proxy:
let p = new Proxy(employee, logHandler);
然后访问
p.firstName
p.lastName
p.test
你会发现每一次访问都打印了两个值：
Proxy: Hal
"Hal"
Proxy: Shaw
"Shaw"
Default name
undefined
有趣的是，同样的调用，包在函数中访问的结果和单独访问的结果不一致，但是把Reflect相关的这一行代码注释掉的话，二者的行为就是一致的了。
return Reflect.get(target, fieldName);
其他方法
- Reflect.apply ( target, thisArgument [, argumentsList] )
Reflect.apply和Function.apply基本一样， 下面是基本用法：
var ages = [11, 33, 12, 54, 18, 96];
// Function.prototype style:
var youngest = Math.min.apply(Math, ages);
var oldest = Math.max.apply(Math, ages);
var type = Object.prototype.toString.call(youngest);
// Reflect style:
var youngest = Reflect.apply(Math.min, Math, ages);
var oldest = Reflect.apply(Math.max, Math, ages);
var type = Reflect.apply(Object.prototype.toString, youngest);
Reflect.apply的真正好处是可以避免因Function.prototype.apply受到污染而导致的一系列稀奇古怪的问题，任何代码都有可能不经意间修改了call 或者 apply，如下代码：
function totalNumbers() {
return Array.prototype.reduce.call(arguments, function (total, next) {
return total + next;
}, 0);
}
totalNumbers.apply = function () {
throw new Error('Aha got you!');
}
totalNumbers.apply(null, [1, 2, 3, 4]); // throws Error('Aha got you!');
// The only way to defensively do this in ES5 code is horrible:
Function.prototype.apply.call(totalNumbers, null, [1, 2, 3, 4]) === 10;
//You could also do this, which is still not much cleaner:
Function.apply.call(totalNumbers, null, [1, 2, 3, 4]) === 10;
// Reflect.apply to the rescue!
Reflect.apply(totalNumbers, null, [1, 2, 3, 4]) === 10;
- Reflect.construct ( target, argumentsList [, constructorToCreateThis] )
与Reflect.apply类似，Reflect.construct允许调用带有多个参数的Constructor，这将会在类中使用到，并且设置正确的对象使这个对象的Constructors 可以用于匹配原型。
在ES5中, 可以使用Object.create(Constructor.prototype) 模式, 然后传递给 Constructor.call 或者 Constructor.apply。
区别在于Reflect.construct并不是传递一个对象，仅仅只是传递了constructor，然后Reflect.construct自行进行处理，ES5中的处理方式有点过于繁重，ES6中方式可能会相对简洁许多:
class Greeting {
constructor(name) {
this.name = name;
}
greet() {
return `Hello ${name}`;
}
}
// ES5 style factory:
function greetingFactory(name) {
var instance = Object.create(Greeting.prototype);
Greeting.call(instance, name);
return instance;
}
// ES6 style factory
function greetingFactory(name) {
return Reflect.construct(Greeting, [name], Greeting);
}
// Or, omit the third argument, and it will default to the first argument.
function greetingFactory(name) {
return Reflect.construct(Greeting, [name]);
}
// Super slick ES6 one liner factory function!
const greetingFactory = (name) => Reflect.construct(Greeting, [name]);
总结
- Reflect可以将Object对象的一些明显属于语言内部的方法（比如Object.defineProperty），放到Reflect对象上。
- 修改某些Object方法的返回结果，让其变得更合理。
- 让Object操作都变成函数行为。某些Object操作是命令式，比如name in obj和delete obj[name]，而Reflect.has(obj, name)和Reflect.deleteProperty(obj, name)让它们变成了函数行为。
- Reflect对象的方法与Proxy对象的方法一一对应，只要是Proxy对象的方法，就能在Reflect对象上找到对应的方法。这就让Proxy对象可以方便地调用对应的Reflect方法，完成默认行为，作为修改行为的基础。也就是说，不管Proxy怎么修改默认行为，你总可以在Reflect上获取默认行为。
