当前位置: 移动技术网 > IT编程>开发语言>JavaScript > Vue的响应式原理

Vue的响应式原理

2020年07月24日  | 移动技术网IT编程  | 我要评论

Vue 响应式原理

一、起步

Vue的响应式原理,我们可以从它的兼容性说起,Vue不支持IE8以下版本的浏览器,因为Vue是基于 Object.defineProperty 来实现数据响应的,而 Object.defineProperty 是 ES5 中一个无法 shim 的特性,这也就是为什么 Vue 不支持 IE8 以及更低版本浏览器的原因;Vue通过Object.defineProperty的getter/setter 对收集的依赖项进行监听,在属性被访问和修改时通知变化,进而更新视图数据;

这些 getter/setter 对用户来说是不可见的,但是在内部它们让 Vue 能够追踪依赖,在 property 被访问和修改时通知变更。这里需要注意的是不同浏览器在控制台打印数据对象时对 getter/setter 的格式化并不同,所以建议安装 vue-devtools 来获取对检查数据更加友好的用户界面。

受现代JavaScript 的限制 (以及废弃 Object.observe),Vue不能检测到对象属性的添加或删除。由于 Vue 会在初始化实例时对属性执行 getter/setter 转化过程,所以属性必须在 data 对象上存在才能让Vue转换它,这样才能让它是响应的。

每个组件实例都对应一个 watcher 实例,它会在组件渲染的过程中把“接触”过的数据 property 记录为依赖。之后当依赖项的 setter 触发时,会通知 watcher,从而使它关联的组件重新渲染。

对于对象

Vue 无法检测 property 的添加或移除。由于 Vue 会在初始化实例时对 property 执行 getter/setter 转化,所以 property 必须在 data 对象上存在才能让 Vue 将它转换为响应式的。例如:

var vm = new Vue({
  data:{
    a:1
  }
})

// `vm.a` 是响应式的

vm.b = 2
// `vm.b` 是非响应式的

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

Vue.set(vm.someObject, 'b', 2)

您还可以使用 vm.$set 实例方法,这也是全局 Vue.set 方法的别名:

this.$set(this.someObject,'b',2)

声明响应式

由于 Vue 不允许动态添加根级响应式 property,所以你必须在初始化实例前声明所有根级响应式 property,哪怕只是一个空值:

const app = new Vue({
  el: '#app',
  data: {
    message: '哈哈哈',
    name: '云澈'
  }

})
// 之后设置 `message`
app.message = 'Hello!'

如果你未在 data 选项中声明 message,Vue 将警告你渲染函数正在试图访问不存在的 property。

这样的限制在背后是有其技术原因的,它消除了在依赖项跟踪系统中的一类边界情况,也使 Vue 实例能更好地配合类型检查系统工作。但与此同时在代码可维护性方面也有一点重要的考虑:data 对象就像组件状态的结构 (schema)。提前声明所有的响应式 property,可以让组件代码在未来修改或给其他开发人员阅读时更易于理解。

异步更新队列

Vue 在更新 DOM 时是异步执行的。只要侦听到数据变化,Vue 将开启一个队列,并缓冲在同一事件循环中发生的所有数据变更。如果同一个 watcher 被多次触发,只会被推入到队列中一次。这种在缓冲时去除重复数据对于避免不必要的计算和 DOM 操作是非常重要的。然后,在下一个的事件循环“tick”中,Vue 刷新队列并执行实际 (已去重的) 工作。Vue 在内部对异步队列尝试使用原生的 Promise.thenMutationObserversetImmediate,如果执行环境不支持,则会采用 setTimeout(fn, 0) 代替。

例如,当你设置 vm.someData = 'new value',该组件不会立即重新渲染。当刷新队列时,组件会在下一个事件循环“tick”中更新。多数情况我们不需要关心这个过程,但是如果你想基于更新后的 DOM 状态来做点什么,这就可能会有些棘手。虽然 Vue.js 通常鼓励开发人员使用“数据驱动”的方式思考,避免直接接触 DOM,但是有时我们必须要这么做。为了在数据变化之后等待 Vue 完成更新 DOM,可以在数据变化之后立即使用 Vue.nextTick(callback)。这样回调函数将在 DOM 更新完成后被调用。例如:

  <div id="app">
    {{message}}
    {{message}}
    {{message}}
  </div>

const app = new Vue({
  el: '#app',
  data: {
    message: '哈哈哈',
    name: '云澈'
  }

})

vm.message = 'new message' // 更改数据
vm.$el.textContent === 'new message' // false
Vue.nextTick(function () {
vm.$el.textContent === 'new message' // true

在组件内使用 vm.$nextTick() 实例方法特别方便,因为它不需要全局 Vue,并且回调函数中的 this 将自动绑定到当前的 Vue 实例上:

Vue.component('example', {
  template: '<span>{{ message }}</span>',
  data: function () {
    return {
      message: '未更新'
    }
  },
  methods: {
    updateMessage: function () {
      this.message = '已更新'
      console.log(this.$el.textContent) // => '未更新'
      this.$nextTick(function () {
        console.log(this.$el.textContent) // => '已更新'
      })
    }
  }
})

因为 $nextTick() 返回一个 Promise 对象,所以你可以使用新的 ES2017 async/await 语法完成相同的事情:

methods: {
  updateMessage: async function () {
    this.message = '已更新'
    console.log(this.$el.textContent) // => '未更新'
    await this.$nextTick()
    console.log(this.$el.textContent) // => '已更新'
  }
}

Object.defineProperty -> 监听对象属性的改变

在这里插入图片描述

//监听key的改变set设置,get返回
//告诉谁了?谁用就告诉谁
//根据解析HTML代码,获取到那些人有用属性
//message1、message2、message3 各自调用get

        set(newValue) {
          console.log('监听' + key + '改变');
          value = newValue;

          //当监听到对象呗调用,则发出notify
          dep.notify()
        },
        get() {
          console.log('获取' + key + '对应的值');
          return value;
        }

发布者订阅者

通过以下代码简单模拟原理

Observer类是将每个目标对象(即data)的键值转换成getter/setter形式,用于进行依赖收集以及调度更新。

  1. 首先将Observer实例绑定到data的ob属性上面去,防止重复绑定;
  2. 若data为数组,先实现对应的变异方法(这里变异方法是指Vue重写了数组的7种原生方法,这里不做赘述,后续再说明),再将数组的每个成员进行observe,使之成响应式数据;
  3. 否则执行walk()方法,遍历data所有的数据,进行getter/setter绑定,这里的核心方法就是 defineReative(obj, keys[i], obj[keys[i]])

其中getter方法:

  1. 先为每个data声明一个 Dep 实例对象,被用于getter时执行dep.depend()进行收集相关的依赖;
  2. 根据Dep.target来判断是否收集依赖,还是普通取值。Dep.target是在什么时候,如何收集的后面再说明,先简单了解它的作用,

在setter方法中:

  1. 获取新的值并且进行observe,保证数据响应式;
  2. 通过dep对象通知所有观察者去更新数据,从而达到响应式效果。

在Observer类中,我们可以看到在getter时,dep会收集相关依赖,即收集依赖的watcher,然后在setter操作时候通过dep去通知watcher,此时watcher就执行变化

Watcher是一个观察者对象。依赖收集以后Watcher对象会被保存在Dep的subs中,数据变动的时候Dep会通知Watcher实例,然后由Watcher实例回调cb进行视图的更新。

被Observer的data在触发 getter 时,Dep 就会收集依赖的 Watcher ,其实 Dep 就像刚才说的是一个书店,可以接受多个订阅者的订阅,当有新书时即在data变动时,就会通过 DepWatcher 发通知进行更新。

    const obj = {
      message: '哈哈哈',
      name: '云澈'
    }
    //通过下面的遍历拿到对象的数据
    Object.keys(obj).forEach(key => {
      let value = obj[key];
      //通过下面的方法监听数据改变
      Object.defineProperty(obj, key, {
        //监听key的改变set设置,get返回
        //告诉谁了?谁用就告诉谁
        //根据解析HTML代码,获取到那些人有用属性
        //message1、message2、message3 各自调用get
        set(newValue) {
          console.log('监听' + key + '改变');
          value = newValue;

          //当监听到对象呗调用,则发出notify
          dep.notify()
        },
        get() {
          console.log('获取' + key + '对应的值');
          return value;
        }
      })
    })

//发布者订阅者(类似于观察者模式)
class Dep {
  constructor() {
    //次数组用于记录谁 使用 属性了
    this.subscribes = []
  }
  //添加订阅者
  addSub(watch) {
    this.subscribes.push(watch);
  }

  //通知方法
  notify() {
    this.subscribes.forEach(item => {
      item.update();
    })
  }
}
//订阅者对象
class Watch {
  constructor(name) {
    this.name = name;
  }
  update() {
    console.log(this.name + '发生了update');
  }
}

const dep = new Dep();

const w1 = new Watch('张三');
dep.addSub(w1);
const w2 = new Watch('李四');
dep.addSub(w2);
const w3 = new Watch('王五');
dep.addSub(w3);

dep.notify()

其实在 Vue 中初始化渲染时,视图上绑定的数据就会实例化一个 Watcher,依赖收集就是是通过属性的 getter 函数完成的,文章一开始讲到的 ObserverWatcherDep 都与依赖收集相关。其中 ObserverDep 是一对一的关系, DepWatcher 是多对多的关系,Dep 则是 ObserverWatcher 之间的纽带。依赖收集完成后,当属性变化会执行被 Observer 对象的 dep.notify() 方法,这个方法会遍历订阅者(Watcher)列表向其发送消息, Watcher 会执行 run 方法去更新视图

  1. Vue 中模板编译过程中的指令或者数据绑定都会实例化一个 Watcher 实例,实例化过程中会触发 get() 将自身指向 Dep.target;
  2. data在 Observer 时执行 getter 会触发 dep.depend() 进行依赖收集;依赖收集的结果:1、data在 Observer 时闭包的dep实例的subs添加观察它的 Watcher 实例;2. Watcher 的deps中添加观察对象 Observer 时的闭包dep;
    的指令或者数据绑定都会实例化一个 Watcher 实例,实例化过程中会触发 get() 将自身指向 Dep.target;
  3. data在 Observer 时执行 getter 会触发 dep.depend() 进行依赖收集;依赖收集的结果:1、data在 Observer 时闭包的dep实例的subs添加观察它的 Watcher 实例;2. Watcher 的deps中添加观察对象 Observer 时的闭包dep;
  4. 当data中被 Observer 的某个对象值变化后,触发subs中观察它的watcher执行 update() 方法,最后实际上是调用watcher的回调函数cb,进而更新视图。

本文地址:https://blog.csdn.net/weixin_45333934/article/details/107511507

如对本文有疑问, 点击进行留言回复!!

相关文章:

验证码:
移动技术网