炼数成金 门户 大数据 JavaScript 查看内容

Vue 数据响应式原理

2018-9-21 15:59| 发布者: 炼数成金_小数| 查看: 24008| 评论: 0|原作者: luobotang|来自: jobbole

摘要: Vue.js 的核心包括一套“响应式系统”。“响应式”,是指当数据改变后,Vue 会通知到使用该数据的代码。例如,视图渲染中使用了数据,数据改变后,视图也会自动更新。

Python Java Hadoop 培训 源码 函数

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

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

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

var vm = new Vue({
  el: '#root',
  data: {
    name: 'luobo'
  }
})

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

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

vm.name = 'tang'

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

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

基本概念
Vue 的响应式,核心机制是 观察者模式。

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

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

data -> watcher

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

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

data - dep -> watcher

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 的关系:
var vm = new Vue({
  data: {
    name: 'luobo',
    age: 18
  }
})
 
var userInfo = function () {
  return this.name + ' - ' + this.age
}
 
var onUserInfoChange = function (userInfo) {
  console.log(userInfo)
}
 
vm.$watch(userInfo, onUserInfoChange)

上面代码首先创建了一个新的 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 中使用了这两个数据)。

接下来,我们修改数据:
vm.name = 'tang'

执行后,控制台会输出:
tang - 18

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

用个简单的图来整理下上面的关系:
vm.name -- dep1
vm.age  -- dep2
watcher.deps --> [dep1, dep2]

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

vm.name -> dep1 -> watcher -> getter -> value -> cb

可能你也注意到了,上面例子中的 userInfo,貌似就是计算属性的作用嘛:
var vm = new Vue({
  data: {
    name: 'luobo',
    age: 18
  },
  computed: {
    userInfo() {
      return this.name + ' - ' + this.age
    }
  }
})

其实,计算属性在内部也是基于 watcher 实现的,每个计算属性对应一个 watcher,其 getter 也就是计算属性的声明函数。

不过,计算属性对应的 watcher 与直接通过 vm.$watch() 创建的 watcher 略有不同,毕竟如果没有地方使用到这个计算属性,数据改变时都重新进行计算会有点浪费,这个在本文后面会讲到。

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

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

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

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

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

var vm = new Vue(/* ... */)

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

observer/state.js#L149

// new Vue() -> ... -> initState() -> initData()
observe(data)

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

observer/index.js#L64

// observe() -> new Observer() -> observer.walk()
defineReactive(obj, key, value)

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

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

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

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

再来看 watcher 的创建过程:
vm.$watch(userInfo, onUserInfoChange)

上述代码执行后,会调用:
instance/state.js#L346

// Vue.prototype.$watch()
new Watcher(vm, expOrFn, cb, options)

也就是:
new Watcher(vm, userInfo, onUserInfoChange, {/* 略 */})

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

observer/watcher.js#L103

// new Watcher() -> watcher.get()
value = this.getter.call(vm, vm)

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

if (Dep.target) {
  dep.depend()
}

这是做什么呢?
回到 watcher.get() 方法,在执行 getter 函数的前后,分别有如下代码:

pushTarget(this)
// ...
value = this.getter.call(vm, vm)
// ...
popTarget()

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

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

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

数据变更同步
继续前面的例子,执行如下代码时:

vm.name = 'tang'

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

// defineReactive() -> set()
dep.notify()

通过 dep 对象来通知所有的依赖方法,于是 dep 遍历内部的 subs 执行:
// dep.notify()
watcher.update()

这样 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

function computedGetter () {
  if (watcher.dirty) {
    watcher.evaluate()
  }
  if (Dep.target) {
    watcher.depend()
  }
  return watcher.value
}

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

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

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

解决这个问题的是上面代码的这一部分:
if (Dep.target) {
  watcher.depend()
}

也就是说,如果当前有在收集依赖的 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 中:

// Vue.prototype.$mount() -> mountComponent()
let updateComponent = () => {
  vm._update(vm._render(), hydrating)
}
new Watcher(vm, updateComponent, noop, null, true /* isRenderWatcher */)

核心代码就在这里了。这个 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

if (this.lazy) {
  this.dirty = true
} else if (this.sync) {
  this.run()
} else {
  queueWatcher(this)
}

第一种情况,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

this.$store = options.store || options.parent.$store

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

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

src/store.js#L251

// new Store() -> resetStoreVM()
store._vm = new Vue({
  data: {
    $$state: state
  },
  computed // 对应 store.getters
})

结合前文的介绍,这里就很好理解了。因为 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

// beforeCreate
Vue.util.defineReactive(this, '_route', this._router.history.current)

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

答案在 VueRouter 的 init() 这里:

history.listen(route => {
  this.apps.forEach((app) => {
    app._route = route
  })
})

一个 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

来看一个使用示例:
const { observe, watch } = require('@luobotang/watch-it')
 
const data = {
  name: 'luobo',
  age: 18
}
 
observe(data)
 
const userInfo = function() {
  return data.name + ' - ' + data.age
}
 
watch(userInfo, (value) => console.log(value))

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

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

watch-it/example/

源码在这里:
luobotang/watch-it/example/vue.js

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

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

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

最后,感谢阅读!

声明:文章收集于网络,如有侵权,请联系小编及时处理,谢谢!

欢迎加入本站公开兴趣群
软件开发技术群
兴趣范围包括:Java,C/C++,Python,PHP,Ruby,shell等各种语言开发经验交流,各种框架使用,外包项目机会,学习、培训、跳槽等交流
QQ群:26931708

Hadoop源代码研究群
兴趣范围包括:Hadoop源代码解读,改进,优化,分布式系统场景定制,与Hadoop有关的各种开源项目,总之就是玩转Hadoop
QQ群:288410967 

鲜花

握手

雷人

路过

鸡蛋

相关阅读

最新评论

热门频道

  • 大数据
  • 商业智能
  • 量化投资
  • 科学探索
  • 创业

即将开课

热门文章

 

GMT+8, 2018-12-17 17:36 , Processed in 0.104029 second(s), 24 queries .