通熟易懂的Vue异步更新策略及 nextTick 原理

时间 2020-05-29

标签易懂 vue 异步更新策略 nexttick 原理繁體版

原文原文链接

最近在学习一些底层方面的知识。因此想作个系列尝试去聊聊这些比较复杂又很重要的知识点。学习就比如是座大山，只有本身去爬山，才能看到不同的风景，体会更加深入。今天咱们就来聊聊Vue中比较重要的异步更新策略及 nextTick 原理。html

在聊话题以前咱们能够看下下面这道面试题：vue

setTimeout(() => {
  console.log('真的在300ms后打印吗？')
}, 300)
复制代码

这段代码很简单，相信不少人都会说yes。固然也不乏大牛的存在，一眼就能看出答案来不必定。这是为何呢？在面试过程当中碰到这类问题如何回答才能让面试官满意，而且如何去扩散咱们的知识点。react

在正式讲解以前咱们能够先了解一些简单的概念：git

什么是进程： 进程是cpu分配资源的最小单位；（是能拥有资源和独立运行的最小单位）github

什么是线程： 线程是cpu调度的最小单位；（线程是创建在进程的基础上的一次程序运行单位，一个进程中能够有多个线程）面试

概念理解起来比较枯燥，作个比喻好了：数组

进程就是一个公司，每一个公司都有本身的资源能够调度；公司之间是相互独立的；而线程就是公司中的每一个员工，多个员工一块儿合做，完成任务，公司能够有一名员工或多个，员工之间共享公司的空间。浏览器

浏览器是多进程的： 在浏览器中，每打开一个tab页面，其实就是新开了一个进程，在这个进程中，还有ui渲染线程，js引擎线程，http请求线程等。因此，浏览器是一个多进程的。bash

js是单线程的： js是做为浏览器的脚本语言，主要是实现用户与浏览器的交互，以及操做dom；这决定了它只能是单线程，不然会带来很复杂的同步问题。举个例子：若是js被设计了多线程，若是有一个线程要修改一个dom元素，另外一个线程要删除这个dom元素，此时浏览器就会一脸茫然，不知所措。因此，为了不复杂性，从一诞生，JavaScript就是单线程。多线程

js执行机制--Event loop

因为js是单线程，js设计者把任务分为同步任务和异步任务，同步任务都在主线程上排队执行，前面任务没有执行完成，后面的任务会一直等待；异步任务则是挂在在一个任务队列里，等待主线程全部任务执行完成后，通知任务队列能够把可执行的任务放到主线程执行。异步任务放到主线程执行完后，又通知任务队列把下一个异步任务放到主线程中执行。这个过程一直持续，直到异步任务执行完成，这个持续重复的过程就叫Event loop。而一次循环就是一次tick 。

在任务队列中的异步任务又能够分为两种microtast（微任务） 和 macrotask（宏任务）

microtast（微任务）：Promise， process.nextTick， Object.observe， MutationObserver

macrotask（宏任务）：script总体代码、setTimeout、 setInterval等

执行优先级上，先执行宏任务macrotask，再执行微任务mincrotask。

执行过程当中须要注意的几点是：

在一次event loop中，microtask在这一次循环中是一直取一直取，直到清空microtask队列，而macrotask则是一次循环取一次。
若是执行事件循环的过程当中又加入了异步任务，若是是macrotask，则放到macrotask末尾，等待下一轮循环再执行。若是是microtask，则放到本次event loop中的microtask任务末尾继续执行。直到microtask队列清空。

到这里，上面那个300ms的定时器为何不必定是精确的300ms以后打印就能理解了：

由于300ms的setTimeout并非说300ms以后立马执行，而是300ms以后被放入任务列表里面。等待事件循环，等待它执行的时候才能执行代码。若是异步任务列表里面只有它这个macrotask任务，那么就是精确的300ms。可是若是还有microtast等其它的任务，就不止300ms了。

扩展一：

在面试过程当中有时也会遇到这类问题。在这以前我觉得考的是let和var的区别，其实它里面也包含着今天讲的知识。

for(var i =0 ;i < 3; i++) {
  console.log("for中i的值："+i)
  var time = setTimeout(() => {
    console.log("setTimeout中i的值："+i)
  }, 300);
}
复制代码

打印的结果致使是什么样的呢：

一、当执行for循环的时候，定义了3个定时器，因为setTimeout是异步任务，全部这三个定时器，都会在300ms以后加入任务队列
二、此时执行代码，依次输出个 for中i的值：一、二、3
300ms以后，每一个setTimeout的加入到任务队列，这时for循环早就执行完毕了，此时的 i 因为主线程执行完以后变成了3。因为这时setTimeout匿名回调函数保持对外部变量 i 的引用，因此最终再打印出3个 setTimeout中i的值：3

用let改变一下结果就不同。最终依次打印出 setTimeout中i的值：一、二、3

for(let i =0 ;i < 3; i++) {
  console.log("for中i的值："+i)
  var time = setTimeout(() => {
    console.log("setTimeout中i的值："+i)
  }, 300);
}
复制代码

一、var声明的变量，在全局范围内都有效，因此在全局只有一个变量i，每一次循环，变量i的值都会发生改变，而循环内部，被赋给setTimeout函数内部的i指向全局的i,结合以前讲的事件执行机制，最后一轮打印的i也都是3了
二、let声明的变量，let只在块及做用域中有效，而且不存在变量提高。因此每次循环在setTimeout中的i都是一个新的变量。

🤔既然每次循环的i都是一个新值，那么结果输出应该都是初始化值1呀？这是由于JavaScript引擎内部会记住上一轮循环的值，初始化本轮变量i时，就在上一轮循环的基础上进行计算

扩展二：

当你完全搞懂一个知识点时，你会发现运用到其余的地方也是同样，咱们接着看下面的代码：

console.log(1);
setTimeout(function () {
  console.log(2)
}, 0); 
new Promise(function (resolve) {
  console.log(3)    
  for (var i = 100; i > 0; i--) {
    i == 1 && resolve()
  }
  console.log(4)
}).then(function () {
  console.log(5)
}).then(function () {
  console.log(6)
});
console.log(7);
复制代码

这段代码在面试中也常常考到，以前我也是很迷糊的，可是当你掌握了今天的知识，你会发现一切都是那么简单

一、因为script也属于macrotask，因此整个script里面的内容都放到了主线程（任务栈）中，按顺序执行代码。而后遇到console.log(1)，直接打印1。
遇到setTimeout,表示0秒后加入任务队列，由于setTimeout是一个宏观任务，因此会放到下一个macrotask，这里不会执行
遇到new Promise，new Promise在实例的过程当中执行代码都是同步进行的，只有回调.then()才是微任务。因此先打印3。执行完循环打印4。而后遇到第一个 .then()，属于microtask，加入到本次循环的microtask队列里面。接着向下执行又遇到一个 .then()，又加入到本次循环的microtask队列里面。而后继续向下执行。
遇到console.log(7)，直接打印7。直到此时，一个事件循环的macrotask执行完成，而后去查看这次循环是否还有microtask，发现还有刚才的 .then() ，当即放到主线程执行，打印出5。而后发现还有第二个 .then()，当即放到主线程执行，打印出6 。此时microtask任务列表清空完了。到此第一次循环完成。
第二次事件循环，从macrotask任务列表里面找到了第一次放进的setTimeout，放到主线程执行，打印出2。
最终打印的结果：一、三、四、七、五、六、2

在vue中的扩展--异步更新策略及 nextTick 原理

平时可能在面试也不乏常常被问到：vue中的nextTick是什么？它的原理和做用是啥？那nextTick究竟是什么，官方文档是这么定义的：

在下次DOM更新循环结束以后执行的延迟回调。在修改数据以后当即使用该方法，获取更新后的DOM。

咱们也能够简单的理解为：当页面中的数据发生改变了，就会把该任务放到一个异步队列中，只有在当前任务空闲时才会进行DOM渲染，当DOM渲染完成之后，该函数就会自动执行。

结合上面讲的微任务去理解，microtask在这一次循环中是一直取一直取，直到清空microtask队列，而macrotask则是一次循环取一次，一次就是一次tick。所以当触发数据的setter，vue在microtask创建一个cb事件，在循环到下一次tick的时候会去自动执行这个事件。

结合源码咱们再去品一下：当触发某个数据的setter方法后，它的setter函数会通知闭包中的Dep，Dep则会调用它管理的全部Watch对象。触发Watch对象的update实现。咱们来看一下update具体是如何实现的。（这里的Dep、Watcher就是Vue响应式的基础了，后面有章节会讲到，这里只须要理解state变化更新的时候，调用update函数更新）

/*调度者接口，当依赖发生改变的时候进行回调 */
  update () {
    /* istanbul ignore else */
    if (this.lazy) {
      this.dirty = true
    } else if (this.sync) {
      /*同步则执行run直接渲染视图*/
      this.run()
    } else {
      /*异步推送到观察者队列中，下一个tick时调用。*/
      queueWatcher(this)
    }
  }
复制代码

从代码中能够看到，当state变化的时候会调用queueWatcher(this)函数，这也是vue异步更新队列的方式。那么咱们跟着去看看queueWatcher作了什么

/*将一个观察者对象push进观察者队列，在队列中已经存在相同的id则该观察者对象将被跳过，除非它是在队列被刷新时推送*/
export function queueWatcher (watcher: Watcher) {
  /*获取watcher的id*/
  const id = watcher.id
  /*检验id是否存在，已经存在则直接跳过，不存在则标记哈希表has，用于下次检验*/
  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 >= 0 && queue[i].id > watcher.id) {
        i--
      }
      queue.splice(Math.max(i, index) + 1, 0, watcher)
    }
    // queue the flush
    if (!waiting) {
      waiting = true
      nextTick(flushSchedulerQueue)
    }
  }
}
复制代码

从queueWatcher代码中看出Watch对象并非当即更新视图，而是被push进了一个队列queue，此时状态处于waiting的状态，这时候会继续会有Watch对象被push进这个队列queue，等到下一个tick运行时将这个队列queue所有拿出来run一遍，这些Watch对象才会被遍历取出，更新视图。同时，id重复的Watcher不会被屡次加入到queue中去。这也解释了同一个watcher被屡次触发，只会被推入到队列中一次。

到这里能够停一下理理思路，借鉴这种图再去细品一下：

从图中和以前讲的Event loop来总结一下：vue为了不频繁的操做DOM,采用异步的方式更新DOM。这些异步操做会经过nextTick函数将这些操做以cb的形式放到任务队列中（以微任务优先），当每次tick结束以后就会去执行这些cb，更新DOM。

vue为了实现异步更新效果，创建了nextTick函数，接下来让咱们一块儿看看nextTick是如何实现的，参考源码地址查看。

/*存放异步执行的回调*/
const callbacks = [] 
/*一个标记位，若是已经有timerFunc被推送到任务队列中去则不须要重复推送*/
let pending = false
/*一个函数指针，指向函数将被推送到任务队列中，等到主线程任务执行完时，任务队列中的timerFunc被调用*/
let timerFunc

/*
  推送到队列中下一个tick时执行
  cb 回调函数
  ctx 上下文
*/
export function nextTick (cb?: Function, ctx?: Object) {
  let _resolve
   // 第一步 传入的cb会被push进callbacks中存放起来
  callbacks.push(() => {
    if (cb) {      
        try {
            cb.call(ctx)
      } catch (e) {
        handleError(e, ctx, 'nextTick')
      }
    } else if (_resolve) {
      _resolve(ctx)
    }
  })  
  // 检查上一个异步任务队列（即名为callbacks的任务数组）是否派发和执行完毕了。pending此处至关于一个锁
  if (!pending) {
  // 若上一个异步任务队列已经执行完毕，则将pending设定为true（把锁锁上）
    pending = true
    // 调用判断Promise，MutationObserver，setTimeout的优先级
    timerFunc()
  }
  // 第三步执行返回的状态
  if (!cb && typeof Promise !== 'undefined') {   
    return new Promise(resolve => {
      _resolve = resolve
    })
  }
}
复制代码

关于timerFunc函数这里省略了，其实就是判断使用Promise，MutationObserver，setTimeout的优先级。系统中会优先用Promise，在Promise不存在的状况下使用MutationObserver，这两个方法都会在microtask中执行，会比setTimeout更早执行，因此优先使用。若是上述两种方法都不支持的环境则会使用setTimeout，在task尾部推入这个函数，等待调用执行。

思考🤔：为何优先执行顺序Promise、MutationObserver 》setTimeout

在主线程上，若是再遇到macrotask，就把它放到macrotask任务队列末尾，因为一次event loop只能取一个macrotask，因此遇到的宏任务就须要等待其它轮次的事件循环了；若是遇到microtask，则放到本次循环的microtask队列中去。这样就能明白为何microtask会比macrotask先处理了。这也是nextTick老是要比setTimeout先要执行。

总结的话，细细品一下官方文档增强理解：官方文档

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