码迷,mamicode.com
首页 > 其他好文 > 详细

ES6——Proxy与Reflect

时间:2020-07-26 15:30:49      阅读:69      评论:0      收藏:0      [点我收藏+]

标签:and   err   apply   conf   desc   str   实现   eof   als   

  • Proxy

    可以对目标对象的读取、函数等操作进行拦截,然后进行操作处理。它不直接操作函数对象,而是像代理模式,通过对象的代理对对象进行操作,在进行这些操作时,可以增加一些需要的额外操作

    • 基本用法

      let target = {
          name: ‘Tom‘,
          age: 24
      }
      let header = {
          get: function (target,key) {
              console.log(‘getting‘+key)
              return target[key]	//注意只能用target[key],不能使用target.key
          },
          set: function (target,key,value) {
              console.log(‘setting‘+key)
              target[key] = value
      
          }
      }
      //生成target的代理对象,对目标对象进行了浅拷贝,因此目标对象和代理对象相互影响
      let proxy = new Proxy(target,header)
      proxy.name      //实际执行的是 hander.get
      console.log(proxy.age = 18)  //实际执行的是 hander.set
      
    • 实例方法

      • get(target,propKey,receiver)

        拦截读取操作

        target: 目标对象

        propKey: 属性

        receiver: Proxy 对象本身

      • set(target,propKey,value,receiver)

        拦截赋值操作

        value: 新赋的值

      • apply(target,ctx,args)

        拦截函数调用、call 和 apply 操作

        ctx: 目标对象上下文

        args: 目标对象参数数组

      • has(target,propKey)

        拦截 HasProperty 操作,即在判断 target 对象是否存在 propKey 属性,会被该方法拦截。但次方法不拦截 for...in 操作

        let hanlder = {
            has: function(target,propKey){
                console.log("handle has")
                return propKey in target
            }
        }
        let exam = {name: ‘Tom‘}
        let proxy = new Proxy(exam,handler)
        "name" in proxy	//handle 	//true
        
      • deleteProperty(target,propKey)

        拦截 delete 操作,如果这个方法抛出异常或返回 false ,propKey 属性将无法被 delete 命令删掉

      • construct(target,args)

        拦截 new 命令,返回值必须是对象

      • defineProperty(target,propKey,propDesc)

        拦截 Object.defineProperty , 若目标不可扩展,增加目标对象上不存在的属性会报错,若属性不可写或不可配置,则不能改变这些属性

      • getOwnPropertyDescriptor(target,propKey)

        拦截 Object.getOwnPropertyDescriptor() ,返回值为属性描述对象或者 undefined

        let handler = {
            getOwnPropertyDescriptor: function(target, propKey){
                return Object.getOwnPropertyDescriptor(target, propKey);
            }
        }
        let target = {name: "Tom"}
        let proxy = new Proxy(target, handler)
        Object.getOwnPropertyDescriptor(proxy, ‘name‘)
        // {value: "Tom", writable: true, enumerable: true, configurable: true}
        
      • getPrototypeOf(target)

        拦截获取对象原型操作

        //包括以下操作
        Object.prototype.__proto__
        Object.prototype.isPrototypeOf()
        Object.getPrototypeOf()
        Reflect.getPrototypeOf()
        instanceof
        

        返回值必须是对象或 null

      • isExtensible(target)

        用于拦截 Object.isExtensible --> 是否是可扩展的

        返回值只能是 boolean 值

      • ownKeys(target)

        用于拦截对象自身属性的读取操作

        //包括以下操作
        Object.getOwnPropertyNames()
        Object.getOwnPropertySymbols()
        Object.keys()
        or...in
        
  • Reflect

    用于获取目标对象行为,与 Object 类似,方法与 Proxy 对应

    • 方法

      • Reflect.get(target,name,receiver)

        查找并返回 target 对象的 name 属性

        let exam = {
            name: "Tom",
            age: 24,
            get info(){
                return this.name + this.age;
            }
        }
        Reflect.get(exam, ‘name‘); // "Tom"
         
        // 当 target 对象中存在 name 属性的 getter 方法, getter 方法的 this 会绑定 // receiver
        let receiver = {
            name: "Jerry",
            age: 20
        }
        Reflect.get(exam, ‘info‘, receiver); // Jerry20
         
        // 当 name 为不存在于 target 对象的属性时,返回 undefined
        Reflect.get(exam, ‘birth‘); // undefined
         
        // 当 target 不是对象时,会报错
        Reflect.get(1, ‘name‘); // TypeError
        
      • Reflect.set(target,name,value,receiver)

        将 target 的 name 属性设置为 value ,返回值为 boolean ,true 表示修改成功, false 表示修改失败。当 target 为不存在的对象时,会报错

      • Reflect.has(obj,name)

        name in obj 指令的函数化,用于查找 name 属性在 obj 对象中是否存在。返回值是 boolean 。如果 obj 不是对象会报错 TypeError

      • Reflect.deleteProperty(obj,property)

        delete obj[property] 的函数化,用于删除 obj 对象的 property 属性,返回值为 boolean 。

      • Reflect.construct(obj,args)

        等同于 new target(...args)

      • Reflect.getPrototype(target)

        用于读取 obj 的 __proto__ 属性。在 obj 不是对象时不会像 Object 一样把 obj 转为对象,而是会报错

      • Reflect.setPrototype(target,newProto)

        用于设置目标对象的 prototype

      • Reflect.apply(func,thisArg,args)

        等同于Function.prototype.apply.call(fun,thisArg,args)。func 表示目标函数;thisArg 表示目标函数绑定的 this 对象;args 表示目标函数调用时传入的参数列表,可以是数组或类似数组的对象。若目标函数无法调用,会抛出 TypeError

      • Reflect.defineProperty(target,propKey,attributes)

        用于为目标对象定义属性。如果 target 不是对象,会抛出错误

      • Reflect.getOwnPropertyDescriptor(target,propKey)

        用于得到 target 对象的 propKey 属性的描述对象

      • Reflect.isExtensible(target)

        用于判断 target 对象是否为可扩展。返回值为 boolean

      • Reflect.preventExtensions(target)

        用于让 target 对象变为不可扩展。

      • Reflect.ownKeys(target)

        用于返回 target 返回的所有属性

  • 组合使用

    Reflect 对象的方法和 Proxy 对象的方法是一一对应的。所有 Proxy 对象的方法可以通过调用 Reflect 对象的方法获取默认行为,然后进行额外操作

    let exam = {
        name: "Tom",
        age: 24
    }
    let handler = {
        get: function(target, key){
            console.log("getting "+key);
            return Reflect.get(target,key);
        },
        set: function(target, key, value){
            console.log("setting "+key+" to "+value)
            Reflect.set(target, key, value);
        }
    }
    let proxy = new Proxy(exam, handler)
    proxy.name = "Jerry"
    proxy.name
    // setting name to Jerry
    // getting name
    // "Jerry"
    
    • 实现观察者模式

      // 定义 Set 集合
      const queuedObservers = new Set();
      // 把观察者函数都放入 Set 集合中
      const observe = fn => queuedObservers.add(fn);
      // observable 返回原始对象的代理,拦截赋值操作
      const observable = obj => new Proxy(obj, {set});
      function set(target, key, value, receiver) {
        // 获取对象的赋值操作
        const result = Reflect.set(target, key, value, receiver);
        // 执行所有观察者
        queuedObservers.forEach(observer => observer());
        // 执行赋值操作
        return result;
      }
      

ES6——Proxy与Reflect

标签:and   err   apply   conf   desc   str   实现   eof   als   

原文地址:https://www.cnblogs.com/angle-yan/p/13379192.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!