第十三章 Reflect

概述

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就会自动执行。