深入理解Vue nextTick 机制
我们先来看一段Vue的执行代码：
exportdefault{
data(){
return{
msg:0
}
},
mounted(){
this.msg=1
this.msg=2
this.msg=3
},
watch:{
msg(){
console.log(this.msg)
}
}
}
这段脚本执行我们猜测1000m后会依次打印：1、2、3。但是实际效果中，只会输出一次：3。为什么会出现这样的情况？我们来一探究竟。
queueWatcher
我们定义watch监听msg，实际上会被Vue这样调用vm.$watch(keyOrFn,handler,options)。$watch是我们初始化的时候，为vm绑定的一个函数，用于创建Watcher对象。那么我们看看Watcher中是如何处理handler的：
this.deep=this.user=this.lazy=this.sync=false
...
update(){
if(this.lazy){
this.dirty=true
}elseif(this.sync){
this.run()
}else{
queueWatcher(this)
}
}
...
初始设定this.deep=this.user=this.lazy=this.sync=false，也就是当触发update更新的时候，会去执行queueWatcher方法：
constqueue:Array=[] lethas:{[key:number]:?true}={} letwaiting=false letflushing=false ... exportfunctionqueueWatcher(watcher:Watcher){ constid=watcher.id if(has[id]==null){ has[id]=true if(!flushing){ queue.push(watcher) }else{ //ifalreadyflushing,splicethewatcherbasedonitsid //ifalreadypastitsid,itwillberunnextimmediately. leti=queue.length-1 while(i>index&&queue[i].id>watcher.id){ i-- } queue.splice(i+1,0,watcher) } //queuetheflush if(!waiting){ waiting=true nextTick(flushSchedulerQueue) } } }
这里面的nextTick(flushSchedulerQueue)中的flushSchedulerQueue函数其实就是watcher的视图更新:
functionflushSchedulerQueue(){
flushing=true
letwatcher,id
...
for(index=0;index
另外，关于waiting变量，这是很重要的一个标志位，它保证flushSchedulerQueue回调只允许被置入callbacks一次。接下来我们来看看nextTick函数，在说nexTick之前，需要你对EventLoop、microTask、macroTask有一定的了解，VuenextTick也是主要用到了这些基础原理。如果你还不了解，可以参考我的这篇文章EventLoop简介好了，下面我们来看一下他的实现：
exportconstnextTick=(function(){
constcallbacks=[]
letpending=false
lettimerFunc
functionnextTickHandler(){
pending=false
constcopies=callbacks.slice(0)
callbacks.length=0
for(leti=0;i{
setImmediate(nextTickHandler)
}
}elseif(typeofMessageChannel!=='undefined'&&(
isNative(MessageChannel)||
//PhantomJS
MessageChannel.toString()==='[objectMessageChannelConstructor]'
)){
constchannel=newMessageChannel()
constport=channel.port2
channel.port1.onmessage=nextTickHandler
timerFunc=()=>{
port.postMessage(1)
}
}else
/*istanbulignorenext*/
if(typeofPromise!=='undefined'&&isNative(Promise)){
//usemicrotaskinnon-DOMenvironments,e.g.Weex
constp=Promise.resolve()
timerFunc=()=>{
p.then(nextTickHandler)
}
}else{
//fallbacktosetTimeout
timerFunc=()=>{
setTimeout(nextTickHandler,0)
}
}
returnfunctionqueueNextTick(cb?:Function,ctx?:Object){
let_resolve
callbacks.push(()=>{
if(cb){
try{
cb.call(ctx)
}catch(e){
handleError(e,ctx,'nextTick')
}
}elseif(_resolve){
_resolve(ctx)
}
})
if(!pending){
pending=true
timerFunc()
}
//$flow-disable-line
if(!cb&&typeofPromise!=='undefined'){
returnnewPromise((resolve,reject)=>{
_resolve=resolve
})
}
}
})()
首先Vue通过callback数组来模拟事件队列，事件队里的事件，通过nextTickHandler方法来执行调用，而何事进行执行，是由timerFunc来决定的。我们来看一下timeFunc的定义：
if(typeofsetImmediate!=='undefined'&&isNative(setImmediate)){
timerFunc=()=>{
setImmediate(nextTickHandler)
}
}elseif(typeofMessageChannel!=='undefined'&&(
isNative(MessageChannel)||
//PhantomJS
MessageChannel.toString()==='[objectMessageChannelConstructor]'
)){
constchannel=newMessageChannel()
constport=channel.port2
channel.port1.onmessage=nextTickHandler
timerFunc=()=>{
port.postMessage(1)
}
}else
/*istanbulignorenext*/
if(typeofPromise!=='undefined'&&isNative(Promise)){
//usemicrotaskinnon-DOMenvironments,e.g.Weex
constp=Promise.resolve()
timerFunc=()=>{
p.then(nextTickHandler)
}
}else{
//fallbacktosetTimeout
timerFunc=()=>{
setTimeout(nextTickHandler,0)
}
}
可以看出timerFunc的定义优先顺序macroTask-->microTask，在没有Dom的环境中，使用microTask，比如weex
setImmediate、MessageChannelVSsetTimeout
我们是优先定义setImmediate、MessageChannel为什么要优先用他们创建macroTask而不是setTimeout？HTML5中规定setTimeout的最小时间延迟是4ms，也就是说理想环境下异步回调最快也是4ms才能触发。Vue使用这么多函数来模拟异步任务，其目的只有一个，就是让回调异步且尽早调用。而MessageChannel和setImmediate的延迟明显是小于setTimeout的。
解决问题
有了这些基础，我们再看一遍上面提到的问题。因为Vue的事件机制是通过事件队列来调度执行，会等主进程执行空闲后进行调度，所以先回去等待所有的进程执行完成之后再去一次更新。这样的性能优势很明显，比如：
现在有这样的一种情况，mounted的时候test的值会被++循环执行1000次。每次++时，都会根据响应式触发setter->Dep->Watcher->update->run。如果这时候没有异步更新视图，那么每次++都会直接操作DOM更新视图，这是非常消耗性能的。所以Vue实现了一个queue队列，在下一个Tick（或者是当前Tick的微任务阶段）的时候会统一执行queue中Watcher的run。同时，拥有相同id的Watcher不会被重复加入到该queue中去，所以不会执行1000次Watcher的run。最终更新视图只会直接将test对应的DOM的0变成1000。保证更新视图操作DOM的动作是在当前栈执行完以后下一个Tick（或者是当前Tick的微任务阶段）的时候调用，大大优化了性能。
有趣的问题
varvm=newVue({
el:'#example',
data:{
msg:'begin',
},
mounted(){
this.msg='end'
console.log('1')
setTimeout(()=>{//macroTask
console.log('3')
},0)
Promise.resolve().then(function(){//microTask
console.log('promise!')
})
this.$nextTick(function(){
console.log('2')
})
}
})
这个的执行顺序想必大家都知道先后打印：1、promise、2、3。
- 因为首先触发了this.msg='end'，导致触发了watcher的update，从而将更新操作callbackpush进入vue的事件队列。
- this.$nextTick也为事件队列push进入了新的一个callback函数，他们都是通过setImmediate-->MessageChannel-->Promise-->setTimeout来定义timeFunc。而Promise.resolve().then则是microTask，所以会先去打印promise。
- 在支持MessageChannel和setImmediate的情况下，他们的执行顺序是优先于setTimeout的（在IE11/Edge中，setImmediate延迟可以在1ms以内，而setTimeout有最低4ms的延迟，所以setImmediate比setTimeout(0)更早执行回调函数。其次因为事件队列里，优先收入callback数组）所以会打印2，接着打印3
- 但是在不支持MessageChannel和setImmediate的情况下，又会通过Promise定义timeFunc,也是老版本Vue2.4之前的版本会优先执行promise。这种情况会导致顺序成为了：1、2、promise、3。因为this.msg必定先会触发dom更新函数，dom更新函数会先被callback收纳进入异步时间队列，其次才定义Promise.resolve().then(function(){console.log('promise!')})这样的microTask，接着定义$nextTick又会被callback收纳。我们知道队列满足先进先出的原则，所以优先去执行callback收纳的对象。
后记
如果你对Vue源码感兴趣，可以来这里：更多好玩的Vue约定源码解释
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持毛票票。