监听一个变量的变化，需要怎么做

本文转载自微信公众号「三分钟学前端」，作者sisterAn。转载本文请联系三分钟学前端公众号。

在峡江等地区，都构建了全面的区域性战略布局，加强发展的系统性、市场前瞻性、产品创新能力，以专注、极致的服务理念，为客户提供网站设计、网站制作 网站设计制作定制网站制作,公司网站建设,企业网站建设,成都品牌网站建设,营销型网站,成都外贸网站建设,峡江网站建设费用合理。

监听一个变量的变化，当变量变化时执行某些操作，这类似现在流行的前端框架(例如 React、Vue等)中的数据绑定功能，在数据更新时自动更新 DOM 渲染，那么如何实现数据绑定喃?

本文给出两种思路：

  • ES5 的 Object.defineProperty
  • ES6 的 Proxy

ES5 的 Object.defineProperty

Object.defineProperty() 方法会直接在一个对象上定义一个新属性，或者修改一个对象的现有属性，并返回此对象

——MDN

 
 
 
    
  
  
  
  1. Object.defineProperty(obj, prop, descriptor) 
    2.

其中：

  • obj ：要定义属性的对象
  • prop ：要定义或修改的属性的名称或 Symbol
  • descriptor ：要定义或修改的属性描述符
 
 
 
    
  
  
  
  1. var user = {  
    2. 
  
  
  
  2.     name: 'sisterAn'  
    3. 
  
  
  
  3. } 
    4. 
  
  
  
  4.  
    5. 
  
  
  
  5. Object.defineProperty(user, 'name', { 
    6. 
  
  
  
  6.     enumerable: true, 
    7. 
  
  
  
  7.     configurable:true, 
    8. 
  
  
  
  8.     set: function(newVal) { 
    9. 
  
  
  
  9.         this._name = newVal  
    10. 
  
  
  
  10.         console.log('set: ' + this._name) 
    11. 
  
  
  
  11.     }, 
    12. 
  
  
  
  12.     get: function() { 
    13. 
  
  
  
  13.         console.log('get: ' + this._name) 
    14. 
  
  
  
  14.         return this._name 
    15. 
  
  
  
  15.     } 
    16. 
  
  
  
  16. }) 
    17. 
  
  
  
  17.  
    18. 
  
  
  
  18. user.name = 'an' // set: an 
    19. 
  
  
  
  19. console.log(user.name) // get: an 
    20.

如果是完整的对变量的每一个子属性进行监听：

 
 
 
    
  
  
  
  1. // 监视对象 
    2. 
  
  
  
  2. function observe(obj) { 
    3. 
  
  
  
  3.    // 遍历对象，使用 get/set 重新定义对象的每个属性值 
    4. 
  
  
  
  4.     Object.keys(obj).map(key => { 
    5. 
  
  
  
  5.         defineReactive(obj, key, obj[key]) 
    6. 
  
  
  
  6.     }) 
    7. 
  
  
  
  7. } 
    8. 
  
  
  
  8.  
    9. 
  
  
  
  9. function defineReactive(obj, k, v) { 
    10. 
  
  
  
  10.     // 递归子属性 
    11. 
  
  
  
  11.     if (typeof(v) === 'object') observe(v) 
    12. 
  
  
  
  12.      
    13. 
  
  
  
  13.     // 重定义 get/set 
    14. 
  
  
  
  14.     Object.defineProperty(obj, k, { 
    15. 
  
  
  
  15.         enumerable: true, 
    16. 
  
  
  
  16.         configurable: true, 
    17. 
  
  
  
  17.         get: function reactiveGetter() { 
    18. 
  
  
  
  18.             console.log('get: ' + v) 
    19. 
  
  
  
  19.             return v 
    20. 
  
  
  
  20.         }, 
    21. 
  
  
  
  21.         // 重新设置值时，触发收集器的通知机制 
    22. 
  
  
  
  22.         set: function reactiveSetter(newV) { 
    23. 
  
  
  
  23.             console.log('set: ' + newV) 
    24. 
  
  
  
  24.             v = newV 
    25. 
  
  
  
  25.         }, 
    26. 
  
  
  
  26.     }) 
    27. 
  
  
  
  27. } 
    28. 
  
  
  
  28.  
    29. 
  
  
  
  29. let data = {a: 1} 
    30. 
  
  
  
  30. // 监视对象 
    31. 
  
  
  
  31. observe(data) 
    32. 
  
  
  
  32. data.a // get: 1 
    33. 
  
  
  
  33. data.a = 2 // set: 2 
    34.

通过 map 遍历，通过深度递归监听子子属性

注意， Object.defineProperty 拥有以下缺陷：

  • IE8 及更低版本 IE 是不支持的
  • 无法检测到对象属性的新增或删除
  • 如果修改数组的 length ( Object.defineProperty 不能监听数组的长度)，以及数组的 push 等变异方法是无法触发 setter 的

对此，我们看一下 vue2.x 是如何解决这块的?

vue2.x 中如何监测数组变化

使用了函数劫持的方式，重写了数组的方法，Vue 将 data 中的数组进行了原型链重写，指向了自己定义的数组原型方法。这样当调用数组 api 时，可以通知依赖更新。如果数组中包含着引用类型，会对数组中的引用类型再次递归遍历进行监控。这样就实现了监测数组变化。

对于数组而言，Vue 内部重写了以下函数实现派发更新

 
 
 
    
  
  
  
  1. // 获得数组原型 
    2. 
  
  
  
  2. const arrayProto = Array.prototype 
    3. 
  
  
  
  3. export const arrayMethods = Object.create(arrayProto) 
    4. 
  
  
  
  4. // 重写以下函数 
    5. 
  
  
  
  5. const methodsToPatch = [ 
    6. 
  
  
  
  6.   'push', 
    7. 
  
  
  
  7.   'pop', 
    8. 
  
  
  
  8.   'shift', 
    9. 
  
  
  
  9.   'unshift', 
    10. 
  
  
  
  10.   'splice', 
    11. 
  
  
  
  11.   'sort', 
    12. 
  
  
  
  12.   'reverse' 
    13. 
  
  
  
  13. ] 
    14. 
  
  
  
  14. methodsToPatch.forEach(function (method) { 
    15. 
  
  
  
  15.   // 缓存原生函数 
    16. 
  
  
  
  16.   const original = arrayProto[method] 
    17. 
  
  
  
  17.   // 重写函数 
    18. 
  
  
  
  18.   def(arrayMethods, method, function mutator (...args) { 
    19. 
  
  
  
  19.   // 先调用原生函数获得结果 
    20. 
  
  
  
  20.     const result = original.apply(this, args) 
    21. 
  
  
  
  21.     const ob = this.__ob__ 
    22. 
  
  
  
  22.     let inserted 
    23. 
  
  
  
  23.     // 调用以下几个函数时，监听新数据 
    24. 
  
  
  
  24.     switch (method) { 
    25. 
  
  
  
  25.       case 'push': 
    26. 
  
  
  
  26.       case 'unshift': 
    27. 
  
  
  
  27.         inserted = args 
    28. 
  
  
  
  28.         break 
    29. 
  
  
  
  29.       case 'splice': 
    30. 
  
  
  
  30.         inserted = args.slice(2) 
    31. 
  
  
  
  31.         break 
    32. 
  
  
  
  32.     } 
    33. 
  
  
  
  33.     if (inserted) ob.observeArray(inserted) 
    34. 
  
  
  
  34.     // 手动派发更新 
    35. 
  
  
  
  35.     ob.dep.notify() 
    36. 
  
  
  
  36.     return result 
    37. 
  
  
  
  37.   }) 
    38. 
  
  
  
  38. }) 
    39.

vue2.x 怎么解决给对象新增属性不会触发组件重新渲染的问题

受现代 JavaScript 的限制 ( Object.observe 已被废弃)，Vue 无法检测到对象属性的添加或删除。

由于 Vue 会在初始化实例时对属性执行 getter/setter 转化，所以属性必须在 data 对象上存在才能让 Vue 将它转换为响应式的。

对于已经创建的实例，Vue 不允许动态添加根级别的响应式属性。但是，可以使用 Vue.set(object, propertyName, value) 方法向嵌套对象添加响应式属性。

vm.$set()实现原理

 
 
 
    
  
  
  
  1. export function set(target: Array | Object, key: any, val: any): any { 
    2. 
  
  
  
  2.   // target 为数组 
    3. 
  
  
  
  3.   if (Array.isArray(target) && isValidArrayIndex(key)) { 
    4. 
  
  
  
  4.     // 修改数组的长度, 避免索引>数组长度导致 splice() 执行有误 
    5. 
  
  
  
  5.     target.length = Math.max(target.length, key); 
    6. 
  
  
  
  6.     // 利用数组的 splice 方法触发响应式 
    7. 
  
  
  
  7.     target.splice(key, 1, val); 
    8. 
  
  
  
  8.     return val; 
    9. 
  
  
  
  9.   } 
    10. 
  
  
  
  10.   // target 为对象, key 在 target 或者 target.prototype 上 且必须不能在 Object.prototype 上,直接赋值 
    11. 
  
  
  
  11.   if (key in target && !(key in Object.prototype)) { 
    12. 
  
  
  
  12.     target[key] = val; 
    13. 
  
  
  
  13.     return val; 
    14. 
  
  
  
  14.   } 
    15. 
  
  
  
  15.   // 以上都不成立, 即开始给 target 创建一个全新的属性 
    16. 
  
  
  
  16.   // 获取 Observer 实例 
    17. 
  
  
  
  17.   const ob = (target: any).__ob__; 
    18. 
  
  
  
  18.   // target 本身就不是响应式数据, 直接赋值 
    19. 
  
  
  
  19.   if (!ob) { 
    20. 
  
  
  
  20.     target[key] = val; 
    21. 
  
  
  
  21.     return val; 
    22. 
  
  
  
  22.   } 
    23. 
  
  
  
  23.   // 进行响应式处理 
    24. 
  
  
  
  24.   defineReactive(ob.value, key, val); 
    25. 
  
  
  
  25.   ob.dep.notify(); 
    26. 
  
  
  
  26.   return val; 
    27. 
  
  
  
  27. } 
    28.
  • 如果目标是数组,使用 vue 实现的变异方法 splice 实现响应式
  • 如果目标是对象,判断属性存在,即为响应式,直接赋值
  • 如果 target 本身就不是响应式,直接赋值
  • 如果属性不是响应式,则调用 defineReactive 方法进行响应式处理

ES6 的 Proxy

众所周知，尤大大的 vue3.0 版本用 Proxy 代替了defineProperty 来实现数据绑定，因为 Proxy 可以直接监听对象和数组的变化，并且有多达 13 种拦截方法。并且作为新标准将受到浏览器厂商重点持续的性能优化。

Proxy

Proxy 对象用于创建一个对象的代理，从而实现基本操作的拦截和自定义(如属性查找、赋值、枚举、函数调用等)

— MDN

 
 
 
    
  
  
  
  1. const p = new Proxy(target, handler) 
    2.

其中：

  • target ：要使用 Proxy 包装的目标对象(可以是任何类型的对象，包括原生数组，函数，甚至另一个代理)
  • handler ：一个通常以函数作为属性的对象，各属性中的函数分别定义了在执行各种操作时代理 p 的行为
 
 
 
    
  
  
  
  1. var handler = { 
    2. 
  
  
  
  2.     get: function(target, name){ 
    3. 
  
  
  
  3.         return name in target ? target[name] : 'no prop!' 
    4. 
  
  
  
  4.     }, 
    5. 
  
  
  
  5.     set: function(target, prop, value, receiver) { 
    6. 
  
  
  
  6.         target[prop] = value; 
    7. 
  
  
  
  7.         console.log('property set: ' + prop + ' = ' + value); 
    8. 
  
  
  
  8.         return true; 
    9. 
  
  
  
  9.     } 
    10. 
  
  
  
  10. }; 
    11. 
  
  
  
  11.  
    12. 
  
  
  
  12. var user = new Proxy({}, handler) 
    13. 
  
  
  
  13. user.name = 'an' // property set: name = an 
    14. 
  
  
  
  14.  
    15. 
  
  
  
  15. console.log(user.name) // an 
    16. 
  
  
  
  16. console.log(user.age) // no prop! 
    17.

上面提到过 Proxy 总共提供了 13 种拦截行为，分别是：

  • getPrototypeOf / setPrototypeOf
  • isExtensible / preventExtensions
  • ownKeys / getOwnPropertyDescriptor
  • defineProperty / deleteProperty
  • get / set / has
  • apply / construct

感兴趣的可以查看 MDN ，一一尝试一下，这里不再赘述

另外考虑两个问题：

  • Proxy只会代理对象的第一层，那么又是怎样处理这个问题的呢?
  • 监测数组的时候可能触发多次get/set，那么如何防止触发多次呢(因为获取push和修改length的时候也会触发)

Vue3 Proxy

对于第一个问题，我们可以判断当前 Reflect.get 的返回值是否为 Object ，如果是则再通过 reactive 方法做代理， 这样就实现了深度观测。

对于第二个问题，我们可以判断是否是 hasOwProperty

下面我们自己写个案例，通过proxy 自定义获取、增加、删除等行为

 
 
 
    
  
  
  
  1. const toProxy = new WeakMap(); // 存放被代理过的对象 
    2. 
  
  
  
  2. const toRaw = new WeakMap(); // 存放已经代理过的对象 
    3. 
  
  
  
  3. function reactive(target) { 
    4. 
  
  
  
  4.   // 创建响应式对象 
    5. 
  
  
  
  5.   return createReactiveObject(target); 
    6. 
  
  
  
  6. } 
    7. 
  
  
  
  7. function isObject(target) { 
    8. 
  
  
  
  8.   return typeof target === "object" && target !== null; 
    9. 
  
  
  
  9. } 
    10. 
  
  
  
  10. function hasOwn(target,key){ 
    11. 
  
  
  
  11.   return target.hasOwnProperty(key); 
    12. 
  
  
  
  12. } 
    13. 
  
  
  
  13. function createReactiveObject(target) { 
    14. 
  
  
  
  14.   if (!isObject(target)) { 
    15. 
  
  
  
  15.     return target; 
    16. 
  
  
  
  16.   } 
    17. 
  
  
  
  17.   let observed = toProxy.get(target); 
    18. 
  
  
  
  18.   if(observed){ // 判断是否被代理过 
    19. 
  
  
  
  19.     return observed; 
    20. 
  
  
  
  20.   } 
    21. 
  
  
  
  21.   if(toRaw.has(target)){ // 判断是否要重复代理 
    22. 
  
  
  
  22.     return target; 
    23. 
  
  
  
  23.   } 
    24. 
  
  
  
  24.   const handlers = { 
    25. 
  
  
  
  25.     get(target, key, receiver) { 
    26. 
  
  
  
  26.         let res = Reflect.get(target, key, receiver); 
    27. 
  
  
  
  27.         track(target,'get',key); // 依赖收集== 
    28. 
  
  
  
  28.         return isObject(res)  
    29. 
  
  
  
  29.         ?reactive(res):res; 
    30. 
  
  
  
  30.     }, 
    31. 
  
  
  
  31.     set(target, key, value, receiver) { 
    32. 
  
  
  
  32.         let oldValue = target[key]; 
    33. 
  
  
  
  33.         let hadKey = hasOwn(target,key); 
    34. 
  
  
  
  34.         let result = Reflect.set(target, key, value, receiver); 
    35. 
  
  
  
  35.         if(!hadKey){ 
    36. 
  
  
  
  36.           trigger(target,'add',key); // 触发添加 
    37. 
  
  
  
  37.         }else if(oldValue !== value){ 
    38. 
  
  
  
  38.           trigger(target,'set',key); // 触发修改 
    39. 
  
  
  
  39.         } 
    40. 
  
  
  
  40.         return result; 
    41. 
  
  
  
  41.     }, 
    42. 
  
  
  
  42.     deleteProperty(target, key) { 
    43. 
  
  
  
  43.       console.log("删除"); 
    44. 
  
  
  
  44.       const result = Reflect.deleteProperty(target, key); 
    45. 
  
  
  
  45.       return result; 
    46. 
  
  
  
  46.     } 
    47. 
  
  
  
  47.   }; 
    48. 
  
  
  
  48.    
    49. 
  
  
  
  49.   // 开始代理 
    50. 
  
  
  
  50.   observed = new Proxy(target, handlers); 
    51. 
  
  
  
  51.   toProxy.set(target,observed); 
    52. 
  
  
  
  52.   toRaw.set(observed,target); // 做映射表 
    53. 
  
  
  
  53.   return observed; 
    54. 
  
  
  
  54. } 
    55.

总结

Proxy 相比于 defineProperty 的优势：

基于 Proxy 和 Reflect ，可以原生监听数组，可以监听对象属性的添加和删除

不需要深度遍历监听：判断当前 Reflect.get 的返回值是否为 Object ，如果是则再通过 reactive 方法做代理， 这样就实现了深度观测

只在 getter 时才对对象的下一层进行劫持(优化了性能)

所以，建议使用 Proxy 监测变量变化

参考

MDN

带你了解 vue-next(Vue 3.0)之 炉火纯青

文章题目：监听一个变量的变化，需要怎么做
网站URL：http://www.shufengxianlan.com/qtweb/news27/188527.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

外贸建站知识

行业网站建设

公司宣传册设计　　 　宜宾网站设计　　 　成都服务器运维　　 　成都小程序开发　　 　四川成都展柜定制厂家　　 　成都服务器托管　　 　成都网站建设　　 　云主机　　 　重庆托管服务器　　 　成都营销网站建设　　 　界面设计　　 　清舞人间　　 　成都网站设计　　 　成都网站推广　　 　瑞杰企业管理　　 　叙永网站建设　　 　小程序开发　　 　小程序开发　　 　内江服务器托管　　 　全网整合营销