Reflect对象浅析

一、什么是reflect对象

  Reflect对象是一个全局的普通的对象。Reflect的原型就是Object。

  我们首先来验证下 看看Reflect的原型是否是Object, 基本代码如下:

let obj = {};
console.log(Reflect.__proto__ === Object.prototype); // true
console.log(obj.__proto__ === Reflect.__proto__); // true

  Reflect是ES6为了操作对象而新增的API, 为什么要添加Reflect对象呢?它这样设计的目的是为了什么?

1、将Object对象的一些明显属于语言内部的方法(比如Object.defineProperty),放到Reflect对象上,那么以后我们就可以从Reflect对象上可以拿到语言内部的方法。

2、在使用对象的 Object.defineProperty(obj, name, {})时,如果出现异常的话,会抛出一个错误,需要使用try catch去捕获,但是使用 Reflect.defineProperty(obj, name, desc) 则会返回false

try {
  Object.defineProperty(target, property, attributes);
  // success
} catch (e) {
  // failure
}
// 新写法
if (Reflect.defineProperty(target, property, attributes)) {
  // success
} else {
  // failure
}

  让Object操作变成函数行为

'name' in Object //true
// 新写法
Reflect.has(Object,'name') //true

  Reflect与Proxy是相辅相成的,在Proxy上有的方法,在Reflect就一定有

    let target={}
    let handler={
      set(target,proName,proValue,receiver){
        //确认对象的属性赋值成功
        let isSuccess=Reflect.set(target,proName,proValue,receiver)
        if(isSuccess){
          console.log("成功")
        }
        return isSuccess
      }
    }
    let proxy=new Proxy(target,handler)

  确保对象的属性能正确赋值,广义上讲,即确保对象的原生行为能够正常进行,这就是Reflect的作用

二、Reflect的API

  注:由于和Proxy的API一致,所以参数就不解释了。

1、Reflect.get(target,property,receiver):查找并返回target对象的property属性

    let obj={
      //属性yu部署了getter读取函数
      get yu(){
        //this返回的是Reflect.get的receiver参数对象
        return this.name+this.age
      }
    }

    let receiver={
      name:"shen",
      age:"18",
    }
    
    let result=Reflect.get(obj,"yu",receiver)
    console.log(result) //shen18

  如果Reflect.get()的第一个参数不是对象,则会报错。

2、Reflect.set(target,propName,propValue,receiver):设置target对象的propName属性为propValue

    let obj={
      name:"chen"
    }

    let result=Reflect.set(obj,"name","shi")
    console.log(result) //true
    console.log(obj.name) //shi
    let obj={
      age:38,
      set setAge(value){
        return this.age=value
      }
    }

    let receiver={
      age:28
    }

    let result=Reflect.set(obj,"setAge",18,receiver)
    console.log(result) //true
    console.log(obj.age) //38
    console.log(receiver.age) //18

3、Reflect.has(obj,name)

4、Reflect.deleteProperty(obj, name):删除对象的属性

delete obj.name;

Reflect.deleteProperty(obj, 'name');

5、Reflect.construct(target, args)

function Person(name) {
  this.name = name;
}
let person= new Person('chen')

let person = Reflect.construct(Person, ['chen']);

6、Reflect.getPrototypeOf(obj):用于读取对象的proto属性,对应Object.getPrototypeOf(obj)

7、Reflect.setPrototypeOf(obj, newProto):设置目标对象的原型(prototype),对应Object.setPrototypeOf(obj, newProto)方法

8、Reflect.apply(func, thisArg, args):继承目标对象的特定方法

let array=[1,2,3,4,5,6]
let small= Math.min.apply(Math, array) //1
let big = Math.max.apply(Math, array) //6

// 新写法
const small= Reflect.apply(Math.min, Math, array)
const big = Reflect.apply(Math.max, Math, array)

9、Reflect.defineProperty(target, propertyKey, attributes)

Reflect.defineProperty(MyDate, 'now', {
  value: () => Date.now()
});

  与Proxy.defineProperty配合使用

let proxy = new Proxy({}, {
  defineProperty(target, prop, descriptor) {
    console.log(descriptor);
    return Reflect.defineProperty(target, prop, descriptor);
  }
});

proxy .name= 'chen';
// {value: "chen", writable: true, enumerable: true, configurable: true}
p.name // "chen"

  Proxy.defineProperty对属性赋值设置拦截,然后使用Reflect.defineProperty完成赋值

Reflect.getOwnPropertyDescriptor(target, propertyKey):基本等同于Object.getOwnPropertyDescriptor,用于得到指定属性的描述对象

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

Reflect.preventExtensions(target):对应Object.preventExtensions方法,用于让一个对象变为不可扩展。它返回一个布尔值,表示是否操作成功

Reflect.ownKeys (target):用于返回对象的所有属性

Published by

风君子

独自遨游何稽首 揭天掀地慰生平

发表回复

您的电子邮箱地址不会被公开。 必填项已用 * 标注