es6-Reflect

概述
1.Reflect对象与Proxy对象一样.将对象一些明显属于语言内部的方法（例如Object.defineProperty）放到Reflect上.
2.修改Object方法的返回结果,让其变得更合理.

//无法定义属性时会报错  
let obj={name:1}
Object.freeze(obj)
Object.defineProperty(obj,'a',{
        value:'11111'
})
console.log(obj) //error 导致程序无法正常进行 需要借助try catch

//Reflect
let obj={name:1}
Object.freeze(obj)
let flag=Reflect.deleteProperty(obj,'a',{
    value:1111
})

console.log(obj,flag)  //{name:1} true 返回一个布尔值 没有添加成功 程序会正常执行

3.让Object的操作都变成函数式行为.

// 原写法
let obj={name:1}
console.log('name' in obj)  //true

// 现在写法
console.log(Reflect.has(obj,'name')) //true

4.Reflect可以结合Proxy，Reflect对象的方法与Proxy对象的方法一一对应，Proxy对象可以方便的调用对应的Reflect方法,完成默认行为.

let obj={};
let proxy=new Proxy(obj,{
    set(target,key,value){
        Reflect.set(target,key,value)
    },
    deleteProperty(target,key){
        return Reflect.deleteProperty(target,key)
    },
    get(target,key){
        return Reflect.get(target,key)
    },
    has(target,key){
        return Reflect.has(target,key)
    }
})

proxy.name='zdb' //触发set方法
console.log(proxy.name) //触发get方法
console.log(delete proxy.name); //返回boolean值
console.log('name' in proxy)  //出发proxy的has方法

5.Reflect对象，很多操作更易读

//老写法
Function.prototype.apply.call(Marh.floor,undefined.[1.2])
//新写法
Reflect.apply(Math.floor,undefined,[1,2])

Refelect13种静态方法

1.Reflect.get(target,name,receiver) 查找方法并返回target对象的name，如果没有该属性，返回undefined

let obj={
    name:1
}
console.log(Reflect.get(obj,'name')) //1
console.log(Reflect.get(obj,'age')) //undefined

//如果第一个参数不对报错
console.log(Reflect.get(1,'name')) //error

2.Reflec(target,name,value,receiver)t设置target对象的name属性

let obj={name:1}
Reflect.set(obj,'age',20)
console.log(obj) //{ name: 1, age: 20 }

3.Reflect.has(obj,name) 对应 name in obj 里面的in操作符.

let obj={name:1};
console.log('name' in obj); //true
console.log(Reflect.has(obj,'name')) //true

4.Reflect.deleteProperty方法等同于delete obj[name] ，用于删除对象的属性.

let obj={name:1}
Reflect.deleteProperty(obj,'name')
console.log(obj) //{}

5.Reflect.constructor(target,args)方法等同于 new target(...args),提供了一个不使用new ,来构造函数，如果第一个参数不是函数会报错.

class MyConstructor{
    constructor(...arg){
        this.arg=arg
    }
}

//旧写法 
let con=new MyConstructor(1,2,3,4)
console.log(con.arg) //[ 1, 2, 3, 4 ]
//新写法
let arr=[ 1, 2, 3, 4,5 ]
let con1=Reflect.construct(MyConstructor,arr) 
console.log(con1.arg) //[ 1, 2, 3, 4, 5 ]

6.Reflect.getPrototypeOf(obj)方法用于读取对象的proto属性,与Object的区别是,如果参数不是对象,Object..getPrototypeOf会将这个参数转换为对象,在运行,而Reflect.getPrototypeOf会报错

class MyConstructor{
    constructor(...arg){
        this.arg=arg
    }
}
const obj=new MyConstructor()
//旧写法
console.log(Object.getPrototypeOf(obj)===MyConstructor.prototype) //true
//新写法
console.log(Reflect.getPrototypeOf(obj)=== MyConstructor.prototype) //true

7.Reflect.setPrototypeOf(obj,newProto)用于设置目标对象的原型(prototype),对应ObjectReflect.setPrototypeOf（obj,newProto）方法.他返回一个布尔值,表示是否设置成功.

let obj={}
//旧写法
Object.setPrototypeOf(obj,Array.prototype);
//新写法
Reflect.setPrototypeOf(obj,Array.prototype);
console.log(obj.length) //0

//如果无法设置目标对象的原型(比如，目标对象禁止扩展)
Reflect.setPrototypeOf({},null);  //true
Reflect.setPrototypeOf(Object.freeze({}),null) //false

//如果第一个参数不是对象，Object.setPrototypeOf返回第一个参数本身，Reflect.setPrototypeOf会报错
Object.setPrototypeOf(1,{}) //1
Reflect.setPrototypeOf(1,{}) //error

//如果第一个参数是undefined或null，两者都会报错
Object.setPrototypeOf(null,{}) //error
Reflect.setPrototypeOf(null,{}) //error

8.Reflect.apply(func,thisArg,args)等同于Function.prototype.apply.call(func,thisArg,args)用于绑定this对象执行后给定的函数.

const ages=[11,22,12,34,22]

//旧写法

const youngest=Math.min.apply(Math,ages)
const oldest=Math.max.apply(Math,ages)
const type=Object.prototype.toString.call(youngest);

//新写法
const youngest=Reflect.apply(Math.min,Math,ages);
const oldest=Reflect.apply(Math.max,Math,ages);
const type=Reflect.apply(Object.prototype.toString,youngest,[])

9.Reflect.defineProperty(target,propertyKey,attributes)基本等同于Object.defineProperty如果第一个参数不是对象会报错.
10.Reflect.getOwnPropertyDescriptor(target, propertyKey)基本等同于Object.getOwnPropertyDescriptor,用于得到指定属性的描述对象.

let obj={name:1}

//旧写法
let des=Object.getOwnPropertyDescriptor(obj,'name');
console.log(des) //{ value: 1, writable: true, enumerable: true, configurable: true } 如果没有返回undefined

//新写法
let des1=Reflect.getOwnPropertyDescriptor(obj,'name')
console.log(des1)

//第一个参数不是对象Object不会报错 Reflect会报错
Object.getOwnPropertyDescriptor(1,'name')//undefined
Reflect.getOwnPropertyDescriptor(1,'name') //error

11.Reflect.isExtensible(target)返回一个布尔值，表示当前对象是否可扩展.

const myObject = {};
// 旧写法
Object.isExtensible(myObject) // true
// 新写法
Reflect.isExtensible(myObject) // true

//如果参数不是对象Reflect会报错
Object.isExtensible(1) // false
Reflect.isExtensible(1) //error

12.Reflect.preventExtensions(target).用于让一个对象变为不可扩展,返回一个布尔值，表示是否操作成功.

let obj={};
//旧写法
Object.preventExtensions(obj) //Object {}
//新写法
Reflect.preventExtensions(obj) //true

//如果参数不是对象
// ES5 环境
Object.preventExtensions(1) // 报错

// ES6 环境
Object.preventExtensions(1) // 1

// 新写法
Reflect.preventExtensions(1) // 报错

13.Reflect.ownKeys(target)返回一个对象可枚举属性,包括Symbol

 let obj={name:1,[Symbol()]:2222}
console.log(Object.getOwnPropertyNames(obj))  //['name']  获取对象自身属性的属性名 不包含Symbol值作为属性名
console.log(Object.getOwnPropertySymbols(obj)) //[ Symbol() ] //获取对象自身所有Symbol属性的数组
console.log(Reflect.ownKeys(obj)) //[ 'name', Symbol() ] 获取对象自身所有属性名包括Symbol类型 Reflect包含以上两种