关于javascript:Vue源码解读四更新策略

之前介绍过初始化时 Vue 对数据的响应式解决是利用了 Object.defifineProperty()，通过定义对象属性 getter 办法拦挡对象属性的拜访，进行依赖的收集，依赖收集的作用就是在数据变更的时候能告诉到相干依赖进行更新。

当响应式数据产生变更时，会触发拦挡的 setter 函数，先来看看 setter：

// src/core/observer/index.js
export function defineReactive (
  obj: Object,
  key: string,
  val: any,
  customSetter?: ?Function,
  shallow?: boolean
) {
  // ...
  Object.defineProperty(obj, key, {
    enumerable: true,
    configurable: true,
    // ...
    // 劫持批改操作
    set: function reactiveSetter (newVal) {// 旧的 obj[key] 
      const value = getter ? getter.call(obj) : val
      // 如果新旧值一样，则间接 return，无需更新
      if (newVal === value || (newVal !== newVal && value !== value)) {return}
      /* eslint-enable no-self-compare */
      if (process.env.NODE_ENV !== 'production' && customSetter) {customSetter()
      }
      // setter 不存在阐明该属性是一个只读属性，间接 return
      if (getter && !setter) return
      // 设置新值
      if (setter) {setter.call(obj, newVal)
      } else {val = newVal}
      // 对新值进行察看，让新值也是响应式的
      childOb = !shallow && observe(newVal)
      // 依赖告诉更新
      dep.notify()}
  })
}

  // src/core/observer/dep.js
  // 告诉更新
  notify () {const subs = this.subs.slice()
    if (process.env.NODE_ENV !== 'production' && !config.async) {subs.sort((a, b) => a.id - b.id)
    }
    for (let i = 0, l = subs.length; i < l; i++) {subs[i].update()}
  }

遍历 dep 中存储的 watcher，执行 watcher.update()。

// src/core/observer/watcher.js
export default class Watcher {
  // ...
  update () {
    /* istanbul ignore else */
    if (this.lazy) {
      // 懒执行时走这里，比方 computed watcher
      // 将 dirty 置为 true，计算属性的求值就会从新计算
      this.dirty = true
    } else if (this.sync) {
      // 同步执行，在应用 vm.$watch 或者 watch 选项时能够传一个 sync 选项，// 当为 true 时在数据更新时该 watcher 就不走异步更新队列，间接执行 this.run 办法进行更新
      // 这个属性在官网文档中没有呈现
      this.run()} else {
      // 更新时个别都这里，将 watcher 放入 watcher 队列
      queueWatcher(this)
    }
  }
}

// src/core/observer/scheduler.js
const queue: Array<Watcher> = []
let has: {[key: number]: ?true } = {}
let waiting = false
let flushing = false
/**
 * 将 watcher 放入 queue 队列
 */
export function queueWatcher (watcher: Watcher) {
  const id = watcher.id
  // 如果 watcher 曾经存在，则跳过
  if (has[id] == null) {
    // 缓存 watcher.id，用于判断 watcher 是否曾经入队
    has[id] = true
    if (!flushing) {
      // 以后没有处于刷新队列状态，watcher 间接入队
      queue.push(watcher)
    } else {
      // 正在刷新队列，这时用户可能增加新的 watcher, 就会走到这里
      // 从后往前找，找到第一个 watcher.id 比以后队列中 watcher.id 大的地位，而后将本人插入到该地位。放弃队列是有序的。let i = queue.length - 1
      while (i > index && queue[i].id > watcher.id) {i--}
      queue.splice(i + 1, 0, watcher)
    }
    // waiting 保障了 nextTick 的调用只有一次
    if (!waiting) {
      waiting = true
      if (process.env.NODE_ENV !== 'production' && !config.async) {
        // 间接刷新调度队列
        // 个别不会走这儿，Vue 默认是异步执行，如果改为同步执行，性能会大打折扣
        flushSchedulerQueue()
        return
      }
      // nextTick => vm.$nextTick、Vue.nextTick
      nextTick(flushSchedulerQueue)
    }
  }
}

nextTick 等会再看，它的作用次要就是把 flushSchedulerQueue 应用异步工作去执行，先尝试用微工作，不反对的状况再用宏工作去执行。

那么先看看 flushSchedulerQueue 的作用：

// src/core/observer/scheduler.js
function flushSchedulerQueue () {currentFlushTimestamp = getNow()
  flushing = true
  let watcher, id
  // 对队列做了从小到大的排序，目标:
  // 1. 组件的更新由父到子, 因为父组件在子组件之前被创立, 所以 watcher 的创立也是先父后子，执行程序也应该放弃先父后子。// 2. 一个组件的用户 watcher 先于渲染 watcher 执行，认为用户 watcher 创立先于渲染 watcher。// 3. 如果一个组件在父组件的 watcher 执行期间被销毁，那么它对应的 watcher 执行都能够被跳过，所以父组件的 watcher 应该先执行。queue.sort((a, b) => a.id - b.id)
  // 在遍历的时候每次都会对 queue.length 求值，因为在 watcher.run() 的时候，很可能用户会再次增加新的 watcher
  for (index = 0; index < queue.length; index++) {watcher = queue[index]
    // 执行 beforeUpdate 生命周期钩子，在 mount 阶段创立 Watcher 时传入
    if (watcher.before) {watcher.before()
    }
    // 将缓存的 watcher 革除
    id = watcher.id
    has[id] = null
    // 执行 watcher.run，最终触发更新函数
    watcher.run()
    // in dev build, check and stop circular updates.
    if (process.env.NODE_ENV !== 'production' && has[id] != null) {circular[id] = (circular[id] || 0) + 1
      if (circular[id] > MAX_UPDATE_COUNT) {
        warn(
          'You may have an infinite update loop' + (
            watcher.user
              ? `in watcher with expression "${watcher.expression}"`
              : `in a component render function.`
          ),
          watcher.vm
        )
        break
      }
    }
  }
  // 在重置状态之前保留队列的正本
  const activatedQueue = activatedChildren.slice()
  const updatedQueue = queue.slice()
  // 重置刷新队列状态
  resetSchedulerState()
  // keep-alive 组件相干
  callActivatedHooks(activatedQueue)
  // 执行 updated 生命周期钩子
  callUpdatedHooks(updatedQueue)
  // devtool hook
  /* istanbul ignore if */
  if (devtools && config.devtools) {devtools.emit('flush')
  }
}

/**
 * 把这些管制流程状态的一些变量复原到初始值，把 watcher 队列清空。*/
function resetSchedulerState () {
  index = queue.length = activatedChildren.length = 0
  has = {}
  if (process.env.NODE_ENV !== 'production') {circular = {}
  }
  waiting = flushing = false
}

/**
 * 由子组件到父组件顺次执行 updated 生命周期钩子
 */
function callUpdatedHooks (queue) {
  let i = queue.length
  while (i--) {const watcher = queue[i]
    const vm = watcher.vm
    if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {callHook(vm, 'updated')
    }
  }
}

下面代码能够看出 flushSchedulerQueue 的作用就是执行更新队列。通过 watcher.run() 触发最终的更新。

// src/core/observer/watcher.js
export default class Watcher {
  constructor(
    vm: Component,
    expOrFn: string | Function,
    cb: Function,
    options?: ?Object,
    isRenderWatcher?: boolean
  ) {this.cb = cb} 
  run () {if (this.active) {
      // 调用 this.get 办法
      const value = this.get()
      if (
        value !== this.value ||  // 新旧值不相等
        isObject(value) ||   // 新值是对象
        this.deep   // deep 模式
      ) {
        // 更新旧值为新值
        const oldValue = this.value
        this.value = value
        if (this.user) {
          // 如果是用户 watcher
          const info = `callback for watcher "${this.expression}"`
          invokeWithErrorHandling(this.cb, this.vm, [value, oldValue], this.vm, info)
        } else {
          // 渲染 watcher，this.cb = noop，一个空函数
          this.cb.call(this.vm, value, oldValue)
        }
      }
    }
  }
}

这里有两种状况，当 this.user 为 true 的时候代表用户 watcher，在之前介绍过也就是 user watcher , 否则执行渲染 watcher 的逻辑。

user watcher

invokeWithErrorHandling 接管的第一个参数就是咱们自定义侦听属性的回调函数，在初始化侦听属性 initWatch 办法过程中，实例化 new Watcher(vm, expOrFn, cb, options) 的时候传入。
第三个参数就是 [value, oldValue] (新值和旧值)，这也就是为什么在侦听属性的回调函数中能取得新值和旧值。

// src/core/util/error.js
export function invokeWithErrorHandling (
  handler: Function,
  context: any,
  args: null | any[],
  vm: any,
  info: string
) {
  let res
  // 利用 try catch 做一些错误处理
  try {res = args ? handler.apply(context, args) : handler.call(context)
    if (res && !res._isVue && isPromise(res) && !res._handled) {res.catch(e => handleError(e, vm, info + ` (Promise/async)`))
      // issue #9511
      // avoid catch triggering multiple times when nested calls
      res._handled = true
    }
  } catch (e) {handleError(e, vm, info)
  }
  return res
}

渲染 watcher

如果是渲染 watcher 则执行 this.cb.call(this.vm, value, oldValue)。渲染 Wather 的实例化是在挂载时 mountComponent 办法中执行的：

  //  src/core/instance/lifecycle.js
  new Watcher(vm, updateComponent, noop, {before () {if (vm._isMounted && !vm._isDestroyed) {callHook(vm, 'beforeUpdate')
      }
    }
  }, true /* isRenderWatcher */)

export function noop (a?: any, b?: any, c?: any) {} 是一个空函数，所以 this.cb.call(this.vm, value, oldValue)，就是在执行一个空函数。

渲染 watcher 在执行 watcher.run 会调用 this.get()，也就会执行 this.getter.call(vm, vm)。this.getter 理论就是实例化时传入的第二个参数 updateComponent。

//  src/core/instance/lifecycle.js
updateComponent = () => {vm._update(vm._render(), hydrating)
}

所以这就是当咱们去批改组件相干的响应式数据的时候，会触发组件从新渲染的起因，接着就会进入 patch 的过程。

后面介绍了 flushSchedulerQueue 的作用就是去执行更新队列，那么咱们看看 queueWatcher 中的这段代码是怎么回事：

nextTick(flushSchedulerQueue)

// src/core/util/next-tick.js
const callbacks = []
let pending = false

export function nextTick (cb?: Function, ctx?: Object) {
  let _resolve
  // 用 callbacks 数组存储通过包装的 cb 函数
  callbacks.push(() => {if (cb) {
      // 用 try catch 包装回调函数，便于谬误捕捉
      try {cb.call(ctx)
      } catch (e) {handleError(e, ctx, 'nextTick')
      }
    } else if (_resolve) {_resolve(ctx)
    }
  })
  if (!pending) {
    pending = true
    timerFunc()}
  // $flow-disable-line
  if (!cb && typeof Promise !== 'undefined') {
    return new Promise(resolve => {_resolve = resolve})
  }
}

nextTick 第一个参数是一个回调函数，这里的回调函数对应的就是 flushSchedulerQueue 了。通过 try catch 将回调函数包装，用于谬误捕捉，而后将其放入 callbacks 中。

这里应用 callbacks 而不是间接在 nextTick 中执行回调函数的起因是保障在同一个 tick 内屡次执行 nextTick，不会开启多个异步工作，而把这些异步工作都压成一个同步工作，在下一个 tick 执行结束。

接下来当 pending 为 false 的时候执行 timerFunc，pending 为 true，示意正在将工作放入浏览器的工作队列中；pending 为 false，示意工作曾经放入浏览器工作队列中了。

最初，nextTick 在没有传入 cb 回调函数的时候，会返回 promise，提供了一个 .then 的调用。

nextTick().then(() => {})

// src/core/util/next-tick.js
// 能够看到 timerFunc 的作用很简略，就是将 flushCallbacks 函数放入浏览器的异步工作队列中
let timerFunc
if (typeof Promise !== 'undefined' && isNative(Promise)) {const p = Promise.resolve()
  timerFunc = () => {
    // 首选 Promise
    p.then(flushCallbacks)
    /**
     * 在有问题的 UIWebViews 中，Promise.then 不会齐全中断，然而它可能会陷入怪异的状态，* 在这种状态下，回调被推入微工作队列，但队列没有被刷新，直到浏览器须要执行其余工作，例如解决一个计时器。* 因而，咱们能够通过增加空计时器来“强制”刷新微工作队列。*/
    if (isIOS) setTimeout(noop)
  }
  isUsingMicroTask = true
} else if (!isIE && typeof MutationObserver !== 'undefined' && (isNative(MutationObserver) ||
  // PhantomJS and iOS 7.x
  MutationObserver.toString() === '[object MutationObserverConstructor]'
)) {
  // 而后应用 MutationObserver
  let counter = 1
  const observer = new MutationObserver(flushCallbacks)
  const textNode = document.createTextNode(String(counter))
  observer.observe(textNode, {characterData: true})
  timerFunc = () => {counter = (counter + 1) % 2
    textNode.data = String(counter)
  }
  isUsingMicroTask = true
} else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
  // 而后 setImmediate，宏工作
  timerFunc = () => {setImmediate(flushCallbacks)
  }
} else {
  // 最初 setTimeout
  timerFunc = () => {setTimeout(flushCallbacks, 0)
  }
}

// src/core/util/next-tick.js
/**
 *   1、将 pending 置为 false
 *   2、清空 callbacks 数组
 *   3、执行 callbacks 数组中的每一个函数（比方 flushSchedulerQueue、用户调用 nextTick 传递的回调函数）*/
function flushCallbacks () {
  pending = false
  const copies = callbacks.slice(0)
  callbacks.length = 0
  for (let i = 0; i < copies.length; i++) {copies[i]()}
}

不论是全局 API Vue.nextTick，还是实例办法 vm.$nextTick，最初都是调用 next-tick.js 中的 nextTick 办法。

Vue 源码解读（预）：手写一个简易版 Vue

Vue 源码解读（一）：筹备工作

Vue 源码解读（二）：初始化和挂载

Vue 源码解读（三）：响应式原理

Vue 源码解读（四）：更新策略

[Vue 源码解读（五）：render 和 VNode（待续）]()

[Vue 源码解读（六）：update 和 patch（待续）]()

[Vue 源码解读（七）：模板编译（待续）]()

如果感觉还对付的话，给个赞吧！！！也能够来我的集体博客逛逛 https://www.mingme.net/

告诉更新

setter

dep.notify()

watcher.update()

queueWatcher

flushSchedulerQueue

watcher.run()

nextTick

nextTick

timerFunc

flushCallbacks

相干链接