Vue源码分析之nextTick

·  阅读 372
Vue源码分析之nextTick

这是我参与更文挑战的第10天,活动详情查看: 更文挑战

前言

JS单线程

JS是一门单线程语言,同一时刻只能执行一个任务(不考虑Web Worker)。那我们绑定的click事件,setTimeOut都是怎么处理的,毕竟JS引擎是单线程的,它在执行当前任务时用户触发点击事件了要怎么处理??怎么去计时??

这些当然不是JS引擎去做的,虽然JS引擎是单线程的,但是浏览器内核却是多线程的,它提供了别的线程来辅助JS引擎。

比如当JS引擎执行代码块遇到鼠标点击/setTimeout/ajax等,浏览器内核的事件触发线程会把与之对应的事件回调添加到事件触发线程维护的异步队列中(chrome中除了正常使用的消息队列外,还有一个延迟任务队列);当对应的事件满足触发条件时,事件触发线程把事件添加到任务队列的队尾,等待JS引擎空闲了去处理。

而浏览器内核也是提供了定时触发器线程去专门计算setInterval/setTimeout,等计时完毕,告知事件触发线程将回调添任务队列中。

当JS引擎遇到XMLHttpRequest时,浏览器内核会新开一个http异步请求线程去执行,等检测到状态变更时,异步线程会告知事件触发线程将回调放入任务队列。

主线程与执行栈

所有任务都是在JS主线程(JS引擎线程)执行,形成一个执行栈,即所有任务都被放入执行栈等待主线程去执行。当遇到ajax,setTimeout等异步操作任务时,JS引擎不会去等待这些异步任务执行完毕,而是交给浏览器内核其他线程去辅助处理,一旦异步任务有了运行结果,则事件触发线程会将它们的回调函数加入到任务队列中。

一旦执行栈中的所有同步任务执行完成,主线程会去查看任务对列中是否有其他任务执行,如果任务队列不为空,则按先进先出的原则开始执行。主线程会不断重复这一步。

微任务和宏任务

这两个概念比较难解释,看到一个比较好的解释(来自于宏任务和微任务到底是什么):宏任务是宿主发起的,微任务是Javascript发起的。

微任务:promise, mutationObserve

宏任务:JS整体代码, I/O, setTimeout, setInterval, requestAnimationRequest

同步任务与异步任务

  • 同步任务:进入主线程的执行栈,按顺序执行。

  • 异步任务:会进入存储异步任务的列表中,并注册函数,当回调函数满足执行条件时,会将回调函数放入任务队列中。

事件循环

事件循环会先执行当前的JS同步代码(其实每次执行栈中就是一个宏任务),遇到微任务,将它放入微任务队列;在一次宏任务执行完毕,去执行微任务队列中的所有微任务。然后页面渲染或者开始下一次宏任务,每次执行宏任务可以看成是一个tick,即一次事件循环。

nextTick

复习完毕,开始进入今天的正题。Vue官方对nextTick的用法解释是在下次DOM更新循环结束后执行的回调函数,修改了数据后立即执行该方法可以拿到修改后的DOM。

具体代码在src/core/util/next-tick.js中。

export function nextTick (cb?: Function, ctx?: Object) {
  let _resolve
  callbacks.push(() => {
    if (cb) {
      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主要是把我们的回调函数加入到callbacks数组中,这里使用callbacks数组,而不是直接执行回调函数主要是为了保证多次调用nextTick函数时,不会开启多个异步任务,而是把所有nextTick中的回调都写到一个数组中统一一次执行。

在pending为false的情况下调用timerFunc函数。

如果没有传回调函数,直接调用nextTick,Vue自己写了一个Promise来保证代码继续往后走。如this.$nextTick().then( () => {...}),当_resolve执行完会走入then中的代码。

pending

pending默认是false,在调用timerFunc前置为true,然后当调用了flushCallbacks后又置为false。可以看出它就是一个标志位,代表着一个事件循环周期。flushCallbacks是在timerFunc中调用的,来看下这个函数是做了什么。

export let isUsingMicroTask = false

const callbacks = []
let pending = false

function flushCallbacks () {
  pending = false
  const copies = callbacks.slice(0)
  callbacks.length = 0
  for (let i = 0; i < copies.length; i++) {
    copies[i]()
  }
}
复制代码

timerFunc

可以看出timerFunc才是nextTick的精髓所在,它的代码也很短,优先看是否是支持微任务,如果支持promise.then,就在promise.then中执行回调函数;再看是否支持mutationObserver,否则就用宏任务来代替。优先使用setImmediate,其次使用setTimeOut

if (typeof Promise !== 'undefined' && isNative(Promise)) {
  const p = Promise.resolve()
  timerFunc = () => {
    p.then(flushCallbacks)
    // In problematic UIWebViews, Promise.then doesn't completely break, but
    // it can get stuck in a weird state where callbacks are pushed into the
    // microtask queue but the queue isn't being flushed, until the browser
    // needs to do some other work, e.g. handle a timer. Therefore we can
    // "force" the microtask queue to be flushed by adding an empty timer.
    if (isIOS) setTimeout(noop)
  }
  isUsingMicroTask = true
} else if (!isIE && typeof MutationObserver !== 'undefined' && (
  isNative(MutationObserver) ||
  // PhantomJS and iOS 7.x
  MutationObserver.toString() === '[object MutationObserverConstructor]'
)) {
  // Use MutationObserver where native Promise is not available,
  // e.g. PhantomJS, iOS7, Android 4.4
  // (#6466 MutationObserver is unreliable in IE11)
  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)) {
  // Fallback to setImmediate.
  // Technically it leverages the (macro) task queue,
  // but it is still a better choice than setTimeout.
  timerFunc = () => {
    setImmediate(flushCallbacks)
  }
} else {
  // Fallback to setTimeout.
  timerFunc = () => {
    setTimeout(flushCallbacks, 0)
  }
}
复制代码

DOM更新

按照Vue官方文档的说法,我们是可以在nextTick中拿到DOM更新后的数据的,但是文档也说了DOM更新是异步执行的。从代码里已经看到nextTick是下一个事件循环tick执行完后去执行的一个微任务。那DOM更新是在什么时机发生的呢??为什么nextTick可以拿到??

image.png

当绑定的数据发生变化时,即Vue更新DOM时,会执行queueWatcher(this)的逻辑(这块逻辑后续介绍)。

queueWatcher函数定义在src/core/observer/schedule.js,它是把所有的watcher都添加到一个队列中,最后去执行nextTick(flushSchdulerQueue)。所以当监听到数据发生变化时,Vue会立即调用nextTick,把DOM更新的回调函数放到微任务队列中。可以看出,在微任务队列中,开发者自己手动调用的nextTick永远都在Vue数据更新调用的nextTick之后,这也是为什么我们能拿到DOM更新后的数据。

export function queueWatcher (watcher: Watcher) {
  const id = watcher.id
  if (has[id] == null) {
    has[id] = true
    if (!flushing) {
      queue.push(watcher)
    } else {
      // if already flushing, splice the watcher based on its id
      // if already past its id, it will be run next immediately.
      let i = queue.length - 1
      while (i > index && queue[i].id > watcher.id) {
        i--
      }
      queue.splice(i + 1, 0, watcher)
    }
    // queue the flush
    if (!waiting) {
      waiting = true

      if (process.env.NODE_ENV !== 'production' && !config.async) {
        flushSchedulerQueue()
        return
      }
      nextTick(flushSchedulerQueue)
    }
  }
}
复制代码

页面渲染在微任务之后,怎么拿到DOM的呢??

前段时间,有个朋友面头条被问到这块,说按照浏览器的渲染机制,渲染不是在微任务之后执行吗,那又是怎么拿到更新后的DOM节点呢??

其实这是两回事,页面是否渲染好与是否拿到DOM节点没啥关系。渲染线程只是负责把DOM树渲染成UI,Vue在更新了DOM以后,在DOM树里就已经存在新的DOM节点了,JS当然是可以拿到的。

总结

  1. 在现代浏览器中,nextTick实现就是一个微任务,在当前宏任务执行完毕后会去执行它。
  2. nextTick不光是暴露出来给开发者调用,Vue自身依赖更新时也会去调用。开发者的调用回调在数据更新的回调之后,所以可以在nextTick中拿到更新后的DOM数据。
  3. 浏览器的GUI渲染线程只是把我们已经构造好的DOM树渲染到页面上,就算页面还没渲染好,JS引擎线程也是可以拿到新的DOM树的DOM节点。
分类:
前端
标签:
收藏成功!
已添加到「」, 点击更改