Vue 数据响应式原理

前言

Vue.js 的核心包括一套“响应式系统”。

“响应式”,是指当数据改变后,Vue 会通知到使用该数据的代码。例如,视图渲染中使用了数据,数据改变后,视图也会自动更新。

举个简单的例子,对于模板:
{{ name }}
创建一个 Vue 组件:

代码执行后,页面上对应位置会显示:luobo。

如果想改变显示的名字,只需要执行:

这样页面上就会显示修改后的名字了,并不需要去手动修改 DOM 更新数据。

接下来,我们就一起深入了解 Vue 的数据响应式原理,搞清楚响应式的实现机制。

基本概念

Vue 的响应式,核心机制是 观察者模式

数据是被观察的一方,发生改变时,通知所有的观察者,这样观察者可以做出响应,比如,重新渲染然后更新视图。

我们把依赖数据的观察者称为 watcher,那么这种关系可以表示为:

数据可以有多个观察者,怎么记录这种依赖关系呢?

Vue 通过在 data 和 watcher 间创建一个 dep 对象,来记录这种依赖关系:

dep 的结构很简单,除了唯一标识属性 id,另一个属性就是用于记录所有观察者的 subs:

  • id - number
  • subs - [Watcher]

再来看 watcher。

Vue 中 watcher 的观察对象,确切来说是一个求值表达式,或者函数。这个表达式或者函数,在一个 Vue 实例的上下文中求值或执行。这个过程中,使用到数据,也就是 watcher 所依赖的数据。用于记录依赖关系的属性是 deps,对应的是由 dep 对象组成的数组,对应所有依赖的数据。而表达式或函数,最终会作为求值函数记录到 getter 属性,每次求值得到的结果记录在 value 属性:

  • vm - VueComponent
  • deps - [Dep]
  • getter - function
  • value - *

另外,还有一个重要的属性 cb,记录回调函数,当 getter 返回的值与当前 value 不同时被调用:

  • cb - function

我们通过示例来整理下 data、dep、watcher 的关系:

上面代码首先创建了一个新的 Vue 实例对象 vm,包含两个数据字段:name、age。对于这两个字段,Vue 会分别创建对应的 dep 对象,用于记录依赖该数据的 watcher。

然后定义了一个求值函数 userInfo,注意,这个函数会在对应的 Vue 示例上下文中执行,也就是说,执行时的 this 对应的就是 vm。

回调函数 onUserInfoChange 只是打印出新的 watcher 得到的新的值,由 userInfo 执行后生成。

通过 vm.$watch(userInfo, onUserInfoChange),将 vm、getter、cb 集成在一起创建了新的 watcher。创建成功后,watcher 在内部已经记录了依赖关系,watcher.deps 中记录了 vm 的 name、age 对应的 dep 对象(因为 userInfo 中使用了这两个数据)。

接下来,我们修改数据:

执行后,控制台会输出:

同样,如果修改 age 的值,也会最终触发 onUserInfoChange 打印出新的结果。

用个简单的图来整理下上面的关系:

修改 vm.name 后,dep1 通知相关的 watcher,然后 watcher 执行 getter,得到新的 value,再将新的 value 传给 cb:

可能你也注意到了,上面例子中的 userInfo,貌似就是计算属性的作用嘛:

其实,计算属性在内部也是基于 watcher 实现的,每个计算属性对应一个 watcher,其 getter 也就是计算属性的声明函数。
不过,计算属性对应的 watcher 与直接通过 vm.$watch() 创建的 watcher 略有不同,毕竟如果没有地方使用到这个计算属性,数据改变时都重新进行计算会有点浪费,这个在本文后面会讲到。

上面描述了 data、dep、watcher 的关系,但是问题来了,这种依赖关系是如何建立的呢?数据改变后,又是如何通知 watcher 的呢?

接下来我们深入 Vue 源码,搞清楚这两个问题。

建立依赖关系

Vue 源码版本 v2.5.13,文中摘录的部分代码为便于分析进行了简化或改写。

响应式的核心逻辑,都在 Vue 项目的 “vue/src/core/observer” 目录下面。

我们还是先顺着前面示例代码来捋一遍,首先是 Vue 实例化过程:

跟将传入的 data 进行响应式初始化相关的代码,在 “vue/src/core/instance/state.js” 文件中:

observer/state.js#L149

函数 observe() 的目的是让传入的整个对象成为响应式的,它会遍历对象的所有属性,然后执行:

observer/index.js#L64

defineReactive() 就是用于定义响应式数据的核心函数。它主要做的事情包括:

  • 新建一个 dep 对象,与当前数据对应
  • 通过 Object.defineProperty() 重新定义对象属性,配置属性的 set、get,从而数据被获取、设置时可以执行 Vue 的代码

OK,先到这里,关于 Vue 实例化告一段落。

需要要注意的是,传入 Vue 的 data 的所有属性,会被代理到新创建的 Vue 实例对象上,这样通过 vm.name 进行操作的其实就是 data.name,这也是借助 Object.defineProperty() 实现的。

再来看 watcher 的创建过程:

上述代码执行后,会调用:

instance/state.js#L346

也就是:

在 watcher 对象创建过程中,除了记录 vm、getter、cb 以及初始化各种属性外,最重要的就是调用了传入的 getter 函数:

observer/watcher.js#L103

在 getter 函数的执行过程中,获取读取需要的数据,于是触发了前面通过 defineReactive() 配置的 get 方法:

这是做什么呢?

回到 watcher.get() 方法,在执行 getter 函数的前后,分别有如下代码:

pushTarget() 将当前 watcher 设置为 Dep.target,这样在执行到 vm.name 进一步执行对应的 get 方法时,Dep.target 的值就是这里的 watcher,然后通过 dep.depend() 就建立了依赖关系。

dep.depend() 执行的逻辑就比较好推测了,将 watcher(通过 Dep.target 引用到)记录到 dep.subs 中,将 dep 记录到 watcher.deps 中 —— 依赖关系建立了!

然后来看建立的依赖关系是如何使用的。

数据变更同步

继续前面的例子,执行如下代码时:

会触发通过 defineReactive() 配置的 set 方法,如果数据改变,那么:

通过 dep 对象来通知所有的依赖方法,于是 dep 遍历内部的 subs 执行:

这样 watcher 就被通知到了,知道了数据改变,从而继续后续的处理。这里先不展开。

到这里,基本就搞清楚响应式的基本机制了,整理一下:

  • 通过 Object.defineProperty() 替换配置对象属性的 set、get 方法,实现“拦截”
  • watcher 在执行 getter 函数时触发数据的 get 方法,从而建立依赖关系
  • 写入数据时触发 set 方法,从而借助 dep 发布通知,进而 watcher 进行更新

这样再看 Vue 官方的图就比较好理解了:

Vue 响应式原理

图片来源:https://vuejs.org/v2/guide/reactivity.html
上图中左侧是以组件渲染(render)作为 getter 函数来演示响应式过程的,这其实就是 RenderWatcher 这种特殊类型 watcher 的作用机制,后面还会再讲。

计算属性

本文前面提到过计算属性,在 Vue 中也是作为 watcher 进行处理的。计算属性(ComputedWatcher)特殊的地方在于,它其实没有 cb(空函数),只有 getter,并且它的值只在被使用时才计算并缓存。

什么意思呢?

首先,ComputedWatcher 在创建时,不会立即执行 getter(lazy 选项值为 false),这样一开始 ComputedWatcher 并没有和使用到的数据建立依赖关系。

计算属性在被“get”时,首先执行预先定义的 ComputedGetter 函数,这里有一段特殊逻辑:

instance/state.js#L238

首先判断 watcher 是不是 dirty 状态,什么意思呢?

计算属性对应的 watcher 初始创建的时候,并没有执行 getter,这个时候就会设置 dirty 为 true,这样当前获取计算属性的值的时候,会执行 getter 得到 value,然后标记 dirty 为 false。这样后续再获取计算属性的值,不需要再计算(执行 getter),直接就能返回缓存的 value。

另外,计算属性的 watcher 在执行 watcher.evaluate() 是,进一步调用 watcher.get(),从而进行依赖收集。而依赖的数据在改变后,会通知计算属性的 watcher,但是 watcher 只是标记自身为 dirty,而不计算。这样的好处是可以减小开销,只在有地方需要计算属性的值时才执行计算。

如果依赖的数据发生变更,计算属性只是标记 dirty 为 true,会不会有问题呢?

解决这个问题的是上面代码的这一部分:

也就是说,如果当前有在收集依赖的 watcher,那么当前计算属性的 watcher 会间接地通过 watcher.depend() 将依赖关系“继承”给这个 watcher(watcher.depend() 内部是对每个 watcher.deps 记录的 dep 执行 dep.depend() 从而让依赖数据与当前的 watcher 建立依赖关系)。

所以,依赖数据改变,依赖计算属性的 watcher 会直接得到通知,再来获取计算属性的值的时候,计算属性才进行计算求值。

所以,依赖计算属性的 watcher 可以视为依赖 watcher 的 watcher。这样的 watcher 在 Vue 中最常见不过,那就是 RenderWatcher。

RenderWatcher 及异步更新

相信读过前文,你应该对 Vue 响应式原理有基本的认识。那么 Vue 是如何将其运用到视图更新中的呢?答案就是这里要讲的 RenderWatcher。

RenderWatcher 首先是 watcher,只不过和计算属性对应的 ComputedWatcher 类似,它也有些特殊的行为。

RenderWatcher 的创建,在函数 mountComponent 中:

核心代码就在这里了。这个 watcher 就是 Vue 实例对象唯一的 RenderWatcher,在 watcher 构造函数中,会记录到 vm._watcher 上(普通 watcher 只会记录到 vm._watchers 数组中)。

这个 watcher 也会在创建的最后执行 watcher.get(),也就是执行 getter 收集依赖的过程。而在这里,getter 就是 updateComponent,也就是说,执行了渲染+更新 DOM!并且,这个过程中使用到的数据也被收集了依赖关系。

那么,理所当然地,在 render() 中使用到数据,发生改变,自然会通知到 RenderWatcher,从而最终更新视图!

不过,这里会有个疑问:如果进行多次数据修改,那么岂不是要频繁执行 DOM 更新?

这里就涉及到 RenderWatcher 的特殊功能了:异步更新

结合前面内容,我们知道数据更新后,依赖该数据的 watcher 会执行 watcher.update(),这个在前文中没有展开,现在我们来看下这个方法:

observer/watcher.js#L161

第一种情况,lazy 为 true,也就是计算属性,上一节已经提到过,只是标记 dirty 为 true,并不立即计算,不再赘述。sync 为 true 的情况,这里也不管,不过看起来也很简单,就是立即执行计算嘛。

最后的情况,就是这里 RenderWatcher 的场景,并不立即执行,也不是像计算属性那样标记为 dirty 就完了,而是放到了一个队列中。

这个队列是干什么的呢?

相关代码在 observer/scheduler.js 中,简单来说,就是实现了异步更新。

理解其实现,首先要对浏览器的事件循环(Event Loop)机制有一定了解。如果你对事件循环机制不是很了解,可以看下面这篇文章:

JavaScript 运行机制详解:再谈Event Loop – 阮一峰

事件循环机制其实有点复杂,但只有理解事件循环,才能对这里 Vue 异步更新的方案有深入的认识。

基于事件循环机制,RenderWatcher 将其 getter,也就是 updateComponent 函数异步执行,并且,多次触发
RenderWatcher 的 update(),最终也只会执行一次 updateComponent,这样也就解决了性能问题。

不过,随之而来的新问题是,修改完数据,不能直接反应到 DOM 上,而是要等异步更新执行过后才可以,这也是为什么 Vue 提供了 nextTick() 接口,并且要求开发者将对 DOM 的操作放到 nextTick() 回调中执行的原因。

Vuex、Vue-Router

再来看 Vue 套装中的 Vuex、Vue-Router,它们也是基于 Vue 的响应式机制实现功能。

先来看 Vuex,代码版本 v3.0.1

Vuex

在应用了 Vuex 的应用中,所有组件都可以通过 this.$store 来引用到全局的 store,并且在使用了 store 的数据后,还能在数据改变后得到同步,这其实就是响应式的应用了。

首先看 this.$store 的实现,这个其实是通过全局 mixin 实现,代码在:

src/mixin.js#L26

这样在每个组件的 beforeCreate 时,会执行 $store 属性的初始化。

而 store 数据的响应式处理,则是通过实例化一个 Vue 对象实现:

src/store.js#L251

结合前文的介绍,这里就很好理解了。因为 state 以及处理为响应式数据,而 getters 也创建为计算属性,所以对这些数据的使用,就建立依赖关系,从而可以响应数据改变了。

Vue-Router

Vue-Router 中,比较重要的数据是 $route,即当前的页面路由数据,在路由改变的时候,需要替换展示不同组件(router-view 组件实现)。

vm.$route 实践上是来自 Vue.prototype,但其对应的值,最终对应到的是 router.history.current

结合前面的分析,这里的 history.current 肯定得是响应式数据,所以,来找下对其进行初始化的地方,其实是在全局 mixin 的 beforeCreate 这里:

v2.8.1/src/install.js#L27

这样 this._route 就是响应式的了,那么如果页面路由改变,又是如何修改这里的 _route 的呢?

答案在 VueRouter 的 init() 这里:

一个 router 对象可能和多个 vue 实例对象(这里叫作 app)关联,每次路由改变会通知所有的实例对象。

再来看使用 vm.$route 的地方,也就是 VueRouter 的两个组件:

两个组件都是在 render() 中,与 $route 建立了依赖关系,根据 route 的值进行渲染。这里具体过程就不展开了,感兴趣可以看下相关源码(v2.8.1/src/components),原理方面在 RenderWatcher 一节已经介绍过。

实践:watch-it

了解了以上这么多,也想自己试试,把 Vue 响应式相关的核心逻辑剥离出来,做一个单纯的数据响应式的库。由于只关注数据,所以在剥离过程中,将与 Vue 组件/实例对象相关的部分都移除了,包括 watcher.vm 也不再需要,这样 watcher.getter 计算时不再指定上下文对象。

感兴趣,想直接看代码的,可以前往 luobotang/watch-it

watch-it 只包括数据响应式相关的功能,暴露了4个接口:

  • defineReactive(obj, key, val):为对象配置一个响应式数据属性
  • observe(obj):将一个数据对象配置为响应式,内部对所有的属性执行 defineReactive
  • defineComputed(target, key, userDef):为对象配置一个计算属性,内部创建了 watcher
  • watch(fn, cb, options):监听求值函数中数据改变,变化时调用 cb,内部创建了 watcher

来看一个使用示例:

这样,当数据修改时,通过会打印出新的 userInfo 的值。

去除虚拟 DOM,只通过响应式机制,我还构建了一个简单的 Vue,并实现了一个 DEMO:

watch-it/example/

源码在这里:

luobotang/watch-it/example/vue.js

总结

OK,以上就是有关 Vue 响应式原理的全部了,当然,只是我的理解和实践。

在梳理和写下这些内容的过程中,我收获很多,也希望内容能够对你有所帮助。

水平有限,错漏难免,欢迎指出。

最后,感谢阅读!

打赏支持我写出更多好文章,谢谢!

打赏作者

打赏支持我写出更多好文章,谢谢!

任选一种支付方式

1 1 收藏 评论

关于作者:luobotang

前端工程师@网易 个人主页 · 我的文章 · 4 ·  

相关文章

可能感兴趣的话题



直接登录
跳到底部
返回顶部