Reflect

一：归纳

（1）将Object对象的一些明显的内部语言放进了Reflect对象中，在将来的新方法将只部署到Reflect上。

（2）修改某些Object方法返回的结果更加合理。好比在Object没法定义属性时会报错，可是Reflect不会。

//Object
try{
 Object.defineProperty(target,property,attributes)
//success
}catch(e){
 //failure
}

//Reflect

if(Reflect.defineProperty(target,property,attributes)){
  //success
}else{
 failure
}

（3）让Object操做都变成函数行为，好比以前的in，delete 命令式方法都变成函数方法

//Object

'assign' in Object //true

//Reflect
Reflect.has(Object,'assign'); //true

（4）Reflect对象的方法与Proxy对象的方法一一对应，只要是Proxy对象的方法，就能在Reflect对象上找到对应的方法。这就能够用Proxy方法调用对应的Reflect方法完成默认行为。

Proxy(target,{
set:function(target,name,value,receiver){
 var success = Reflect.set(target,name,value,receiver);
   if(success){
     console.log('property' + name + 'on set to' +value) 
   } 
　　return success
}
})
Proxy.name = '你好'
console.log(Proxy.name) 'property name on set to 你好'

//Proxy对象拦截了target对象的属性赋值行为，而后采用Reflect.set()将值赋值给对象的属性，确保完成原有的行为，而后再部署额外的功能。

 经常使用的几种方法

　　注：若是第一参数不是对象则报错

（1）Reflect.get(target,name,receiver)

　　返回target对象的那么属性，若是没有该属性，则返回undefined

//没有部署读取函数
var obj = {
 foo:2 
}
var myObj = {
foo:3
}

Reflect.get(obj,'foo')// 2
Reflect.get(obj,'foo',myObj)// 2

//部署读取函数,读取函数的this会绑定到receiver
var obj = {
 get bar(){
   console.log(this)
 } 
}
var myObj = {
    foo:3
}

Reflect.get(obj,'bar')// obj,由于没有receiver参数
Reflect.get(obj,'bar',myObj)// myObj 

（2）Reflect.set(target,name,value,receiver)

　　设置target的name属性等于value

//有设置赋值函数，可是没有receiver参数
var obj ={
 foo:2
 set bar(value){
   return this.foo = value;  
 } 
}

console.log(obj.foo) //1

Reflect.set(obj,'foo',2) 

console.log(obj.foo) //2

Reflect.set(obj,'bar',3) 

console.log(obj.foo) //3

//有设置赋值函数，则赋值函数的this绑定receiver，存在receiver参数
var obj= {
  foo: 4,
  set bar(value) {
    return this.foo = value;
  },
};

var myObj= {
  foo: 0,


Reflect.set(obj,'bar',5,myObj); //赋值函数的this，即obj的this指向了myObj。因此myObj的foo被赋值了。
console.log(myObj.foo) //5