概述
Reflect对象与Proxy对象一样，都是ES6为了操作对象而提供的新的API。Reflect对象的设计目的有以下几个。
1.将Object对象的一些明显属于语言内部的方法放到Reflect对象上，也就是说从Reflect对象上可以获得语言内部的方法。
2.修改某些Object方法的返回结果，让其变得更合理。比如在Object.defineProperty(obj, name, desc)在无法定义属性时会抛出一个错误，而Reflect.defineProperty(obj, name, desc)则会返回false
3.让Object操作都变成函数行为。某些Object操作是命令式，比如name in obj，而Reflect.has(obj, name)让它们变成了函数行为。
4.Reflect对象的方法与Proxy对象的方法一一对应，只要是Proxy对象的方法，就能在Reflect对象上找到对应的方法。也就是说，无论Proxy怎么修改默认行为，我们总能在Reflect上获取原有的默认行为。
静态方法
Reflect对象一共有13个静态方法，这些方法的作用大部分与Object对象的同名方法作用是相同的，而且与Proxy对象的方法是一一对应的，具体解释如下：
Reflect.get(target, name, receiver)
Reflect.get方法查找并返回target对象的name属性值，如果没有该属性，则返回undefined。
let myObject = {
foo: 1,
bar: 2
get baz () {
return this.foo+this.bar
}
}
let receiver = {
foo: 4,
bar: 4
}
Reflect.get(myObject, 'foo') // 1
Reflect.get(myObject, 'bar') // 2
Reflect.get(myObject, 'baz') // 3
Reflect.get(myObject, 'baz', receiver) // 8
如果name属性部署了读取函数（getter），如果有receiver参数，则读取函数的this绑定receiver，如果没有就绑定上下文。
如果第一个参数不是对象，Reflect.get方法会报错。
Reflect.get(1, 'foo') // 报错
Reflect.set(target, name, value, receiver)
Reflect.set方法设置target对象的name属性等于value
let myObject = {
foo: 1,
set bar (value) {
return this.foo = value
}
}
let receiver = {
foo: 0
}
myObject.foo // 1
Reflect.set(myObject, 'foo', 2)
myObject.foo // 2
Reflect.set(myObject, 'bar', 3)
myObject.foo // 3
Reflect.set(myObject, 'bar', 1, receiver)
myObject.foo // 3
receiver.foo // 1
如果name属性设置了赋值函数，则赋值函数的this绑定receiver。
如果第一个参数不是对象，Reflect.set会报错
注意：Reflect.set会触发Proxy.defineProperty拦截
Reflect.has方法对应name in obj中的in运算符
let myObject = {
foo: 1
}
// 旧写法
'foo' in myObject
// 新写法
Reflect.has(myObject, 'foo') // true
如果第一个参数不是对象，Reflect.has和in运算符都会报错
Reflect.deleteProperty(obj, name)
Reflect.deleteProperty等同于delete obj[name]，用于删除对象的属性。
const myObj = {foo: 'bar'}
// 旧写法
delete myObj.foo
// 新写法
Reflect.deleteProperty(myObj, 'foo')
该方法返回一个布尔值。如果删除成功或被删除的属性不存在，就返回true，如果删除失败或被删除的属性依然存在，就返回false
Reflect.construct(target, args)
Reflect.construct方法等同于new target(...args)，提供了一种不使用new来调用构造函数的方法。
function Greeting (name) {
this.name = name
}
// new的写法
const instance = new Greeting('张三')
// Reflect.construct写法
const instance = Reflect.construct(Greeting, ['张三'])
Reflect.getPrototypeOf(obj)
Reflect.getPrototypeOf方法用于读取对象的proto属性，对应Object.getPrototypeOf(obj)
const myObj = new FancyThing()
// 旧写法
Object.getPrototypeOf(myObj) === FancyThing.prototype
// 新写法
Reflect.getPrototypeOf(myObj) === FancyThing.prototype
这两种写法区别是前者的参数如果不是对象会转为对象，而Reflect.getPrototypeOf会报错
Reflect.setPropertypeOf(obj, newProto)
Reflect.setPropertypeOf方法用于设置对象的proto属性，返回第一个参数对象，对应Object.setPropertypeOf
const myObj = new FancyThing()
// 旧写法
Object.setPropertypeOf(myObj, OtherThing.prototype)
// 新写法
Reflect.setPropertypeOf(myObj, OtherThing.prototype)
如果第一个参数不是对象，Object.setPropertypeOf会返回第一个参数本身，而Reflect.setPropertypeOf会报错。如果第一个参数是undefined或null，那么这两个方法都会报错。
Reflect.apply(func, thisArg, args)
Reflect.apply方法等同于Function.prototype.apply.call(func, thisArg, args),用于绑定this对象后执行给定函数。
const ages = [11,22,33,444]
// 旧写法
const youngest = Math.min.apply(Math, ages)
const type = Object.prototype.toString.call(youngest)
// 新写法
const youngest = Reflect.apply(Math.min, Math, ages)
const type = Reflect.apply(Object.prototype.toString, youngest,[])
Reflect.defineProperty(target, propertyKey, attributes)
Reflect.defineProperty方法基本等同于Object.defineProperty，用来为对象定义属性。
function MyDate() {}
//旧写法
Object.defineProperty(MyDate, 'now', {
value: () => Date.now()
})
// 新写法
Reflect.defineProperty(MyDate, 'now', {
value: () => Date.now()
})
如果Reflect.defineProperty第一个参数不是对象就会报错
Reflect.getOwnPropertyDescriptor(target, properKey)
Reflect.getOwnPropertyDescriptor等同于Object.getOwnPropertyDescriptor，用于获得指定属性的描述对象。
let myObj = {}
Object.defineProperty(myObj, 'hidden', {
value: value,
enumerable: false
})
// 旧写法
let objDescriptor = Object.getOwnPropertyDescriptor(myObj, 'hidden')
// 新写法
let objDescriptor = Reflect.getOwnPropertyDescriptor(myObj, 'hidden')
如果第一个参数不是对象Reflect.getOwnPropertyDescriptor会报错
Reflect.ownKeys(target)
Reflect.ownKeys方法用于返回对象的所有属性，基本等同于Object.getOwnPropertyNames与Object.getOwnPropertySymbols之和。
let myObj = {
foo: 1,
bar: 2,
[Symbol.for('baz')]: 3,
[Symbol.for('bing')]: 4
}
// 旧写法
Object.getOwnPropertyNames(myObj)
// ['foo', 'bar']
Object.getOwnPropertySymbols(myObj)
// [Symbol.for('baz'), Symbol.for('bing')]
// 新写法
Reflect.ownKeys(myObj)
// ['foo', 'bar', Symbol.for('baz'), Symbol.for('bing')]
实例：使用Proxy实现观察者模式
观察者模式指的是函数自动观察数据对象的模式，一旦对象有变化，函数就会自动执行
const person = observable({
name: '张三'，
age: 20
})
function print() {
console.log(`${person.name}, ${person.age}`)
}
observe(print)
person.name = '李四'
// ‘李四’ 20
上面代码中数据对象person是观察目标，函数print是观察者，一旦数据对象发生变化，print就会自动执行。
