ES2015 Reflect 统一的对象操作API

一、Reflect是什么？

Reflect属于一个静态类，也就是说他不能通过new方法去构建一个实例对象 new Reflect。

只能够去调用这个静态类的一些静态方法，比如 Reflect.get( )，Math对象也是如此。

Reflect 内部封装了一系列对对象的底层操作，提供了13个静态方法。

• Reflect.get(target, name, receiver)
• Reflect.set(target, name, value, receiver)
• Reflect.has(target, name)
• Reflect.deleteProperty(target, name)
• Reflect.getPrototypeOf(target)
• Reflect.setPrototypeOf(target, prototype)
• Reflect.isExtensible(target)
• Reflect.preventExtensions(target)
• Reflect.getOwnPropertyDescriptor(target, name)
• Reflect.defineProperty(target, name, desc)
• Reflect.ownKeys(target)
• Reflect.apply(target, thisArg, args)
• Reflect.construct(target, args)

这13个方法的方法名与Proxy对象中的处理对象的方法是完全一致的。

Proxy对象中的处理对象的方法：

handler方法	触发方式
get	读取某个属性
set	写入某个属性
has	in 操作符
deleteProperty	delete操作符
getPrototypeOf	Object.getPrototypeOf()
setPrototypeOf	Object.setPrototypeOf()
isExtensible	Object.isExtensible()
preventExtensions	Object.preventExtensions()
getOwnPropertyDescriptor	Object.getOwnPropertyDescriptor()
defineProperty	Object.defineProperty()
ownKeys	Object.getOwnPropertyNames() 、Object.getOwnPropertySymbols()
apply	调用一个函数
construct	用new调用一个函数

Reflect成员方法就是Proxy处理对象的默认实现。点击查看Proxy

const obj = {
  name : 'luyu',
  age:18
}
const proxy = new Proxy(obj,{
  get(target,property){
    // 自己的处理逻辑
    console.log('watch logic')
    return Reflect.get(target,property)
  }
})
console.log(proxy.foo) // 输出 watch logic   luyu 

二、为什么ES2015新增 Reflect？

Reflect的使用方法很简单，MDN上都可以查到。

很多人可能会觉得疑惑，既然是操作对象，我们以前已经有操作对象的方法了。

为什么还要有新增这个Reflect 呢？它的价值具体体现在什么地方？

Reflect 最大的意义就是：统一提供了一套用于操作对象的API

在这之前，在操作对象时，我们有可能会使用Object对象上的方法，也有可能会使用in 、delete之类的操作符，

这对新手来说太乱了，没什么规律。

看下面的对比例子就明白了：

const obj = {
  name : 'luyu',
  age:18
}
// 判断对象是否存在某个属性
console.log('name' in obj)
console.log(delete obj['age'])
// 获取对象所有的属性名
console.log(Object.keys(obj))


// Reflect 的用法。
// 以后的标准，会把以前的对象操作方法废弃掉，用Reflect来代替

// 判断对象是否存在某个属性
console.log(Reflect.has(obj,'name'))
console.log(Reflect.deleteProperty(obj,'age'))
// 获取对象所有的属性名
console.log(Reflect.ownKeys(obj))

以后的标准，会把以前的对象操作方法废弃掉，用Reflect来代替。

现在就可以用起来啦。