Reflect

定义

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, Reflect is not a constructor. You cannot use it with a new operatoror invoke the Reflect object as a function. All properties and methods of Reflect are static (just like the Math object).

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.apply()
Reflect.construct()
Reflect.defineProperty()
Reflect.deleteProperty()
Reflect.get()
Reflect.getOwnPropertyDescriptor()
Reflect.getPrototypeOf()
Reflect.has()
Reflect.isExtensible()
Reflect.ownKeys()
Reflect.preventExtensions()
Reflect.set()
Reflect.setPrototypeOf()

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上获取默认行为。

参考

https://blog.greenroots.info/javascript-why-reflect-apis-cjx09kad20006sos1pmumyn38
https://www.keithcirkel.co.uk/metaprogramming-in-es6-part-2-reflect/
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect
http://es6.ruanyifeng.com/#docs/reflect

ES6 Reflect用法详解

定义