摘要：這是因為在運行時出錯，我們不這個錯誤的話，會導致整個程序崩潰掉。如果沒有向中傳入，并且瀏覽器支持的話，我們的返回的將是一個。如果不支持，就降低到用，整體邏輯就是這樣。。

我們知道vue中有一個api。Vue.nextTick( [callback, context] )
他的作用是在下次 DOM 更新循環結束之后執行延遲回調。在修改數據之后立即使用這個方法，獲取更新后的 DOM。那么這個api是怎么實現的呢？你肯定也有些疑問或者好奇。下面就是我的探索，分享給大家，也歡迎大家到github上和我進行討論哈~~

首先貼一下vue的源碼,然后我們再一步步的分析

/* @flow */
/* globals MessageChannel */

import { noop } from "shared/util"
import { handleError } from "./error"
import { isIOS, isNative } from "./env"

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]()
  }
}

// Here we have async deferring wrappers using both microtasks and (macro) tasks.
// In < 2.4 we used microtasks everywhere, but there are some scenarios where
// microtasks have too high a priority and fire in between supposedly
// sequential events (e.g. #4521, #6690) or even between bubbling of the same
// event (#6566). However, using (macro) tasks everywhere also has subtle problems
// when state is changed right before repaint (e.g. #6813, out-in transitions).
// Here we use microtask by default, but expose a way to force (macro) task when
// needed (e.g. in event handlers attached by v-on).
let microTimerFunc
let macroTimerFunc
let useMacroTask = false

// Determine (macro) task defer implementation.
// Technically setImmediate should be the ideal choice, but it"s only available
// in IE. The only polyfill that consistently queues the callback after all DOM
// events triggered in the same loop is by using MessageChannel.
/* istanbul ignore if */
if (typeof setImmediate !== "undefined" && isNative(setImmediate)) {
  macroTimerFunc = () => {
    setImmediate(flushCallbacks)
  }
} else if (typeof MessageChannel !== "undefined" && (
  isNative(MessageChannel) ||
  // PhantomJS
  MessageChannel.toString() === "[object MessageChannelConstructor]"
)) {
  const channel = new MessageChannel()
  const port = channel.port2
  channel.port1.onmessage = flushCallbacks
  macroTimerFunc = () => {
    port.postMessage(1)
  }
} else {
  /* istanbul ignore next */
  macroTimerFunc = () => {
    setTimeout(flushCallbacks, 0)
  }
}

// Determine microtask defer implementation.
/* istanbul ignore next, $flow-disable-line */
if (typeof Promise !== "undefined" && isNative(Promise)) {
  const p = Promise.resolve()
  microTimerFunc = () => {
    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)
  }
} else {
  // fallback to macro
  microTimerFunc = macroTimerFunc
}

/**
 * Wrap a function so that if any code inside triggers state change,
 * the changes are queued using a (macro) task instead of a microtask.
 */
export function withMacroTask (fn: Function): Function {
  return fn._withTask || (fn._withTask = function () {
    useMacroTask = true
    const res = fn.apply(null, arguments)
    useMacroTask = false
    return res
  })
}

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
    if (useMacroTask) {
      macroTimerFunc()
    } else {
      microTimerFunc()
    }
  }
  // $flow-disable-line
  if (!cb && typeof Promise !== "undefined") {
    return new Promise(resolve => {
      _resolve = resolve
    })
  }
}

這么多代碼，可能猛的一看，可能有點懵，不要緊，我們一步一步抽出枝干。首先我們看一下這個js文件里的nextTick的定義

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
    if (useMacroTask) {
      macroTimerFunc()
    } else {
      microTimerFunc()
    }
  }
  // $flow-disable-line
  if (!cb && typeof Promise !== "undefined") {
    return new Promise(resolve => {
      _resolve = resolve
    })
  }
}

我將代碼精簡一下。如下所示，下面的代碼估計就比較容易看懂了。把cb函數放到會掉隊列里去，如果支持macroTask，則利用macroTask在下一個事件循環中執行這些異步的任務，如果不支持macroTask，那就利用microTask在下一個事件循環中執行這些異步任務。

export function nextTick (cb?: Function, ctx?: Object) {
  callbacks.push(cb)
    if (useMacroTask) {
      macroTimerFunc()
    } else {
      microTimerFunc()
    }
}

這里再次普及一下js的event loop的相關知識，js中的兩個任務隊列 ：macrotasks、microtasks

macrotasks: script(一個js文件),setTimeout, setInterval, setImmediate, I/O, UI rendering
microtasks: process.nextTick, Promises, Object.observe, MutationObserver

執行過程：
1.js引擎從macrotask隊列中取一個任務執行
2.然后將microtask隊列中的所有任務依次執行完
3.再次從macrotask隊列中取一個任務執行
4.然后再次將microtask隊列中所有任務依次執行完
……
循環往復

那么我們再看我們精簡掉的代碼都是干什么的呢？我們往異步隊列里放回調函數的時候，我們并不是直接放回調函數，而是包裝了一個函數，在這個函數里調用cb，并且用try catch包裹了一下。這是因為cb在運行時出錯，我們不try catch這個錯誤的話，會導致整個程序崩潰掉。 我們還精簡掉了如下代碼

  if (!cb && typeof Promise !== "undefined") {
    return new Promise(resolve => {
      _resolve = resolve
    })
  }

這段代碼是干嘛的呢？也就是說我們用nextTick的時候，還可以有promise的寫法。如果沒有向nextTick中傳入cb，并且瀏覽器支持Promise的話，我們的nextTick返回的將是一個Promise。所以，nextTick的寫法也可以是如下這樣的

 nextTick().then(()=>{console.log("XXXXX")})

vue源碼里關于nextTick的封裝的思路，也給我們一些非常有益的啟示，就是我們平時在封裝函數的時候，要想同時指出回調和promise的話，就可以借鑒vue中的思路。

大致的思路我們已經捋順了。但是為什么執行macroTimerFunc或者microTimerFunc就會在下一個tick執行我們的回調隊列呢？下面我們來分析一下這兩個函數的定義。首先我們分析macroTimerFunc

let macroTimerFunc

if (typeof setImmediate !== "undefined" && isNative(setImmediate)) {
  macroTimerFunc = () => {
    setImmediate(flushCallbacks)
  }
} else if (typeof MessageChannel !== "undefined" && (
  isNative(MessageChannel) ||
  // PhantomJS
  MessageChannel.toString() === "[object MessageChannelConstructor]"
)) {
  const channel = new MessageChannel()
  const port = channel.port2
  channel.port1.onmessage = flushCallbacks
  macroTimerFunc = () => {
    port.postMessage(1)
  }
} else {
  /* istanbul ignore next */
  macroTimerFunc = () => {
    setTimeout(flushCallbacks, 0)
  }
}

從上邊的代碼可以看出，如果瀏覽器支持setImmediate，我們就用setImmediate，如果瀏覽器支持MessageChannel，我們就用MessageChannel的異步特性，如果兩者都不支持，我們就降價到setTimeout
，用setTimeout來把callbacks中的任務在下一個tick中執行

  macroTimerFunc = () => {
    setTimeout(flushCallbacks, 0)
  }

分析完macroTimerFunc，下面我們開始分析microTimerFunc，我把vue源碼中關于microTimerFunc的定義稍微精簡一下

let microTimerFunc;
if (typeof Promise !== "undefined" && isNative(Promise)) {
  const p = Promise.resolve()
  microTimerFunc = () => {
    p.then(flushCallbacks)
  }
} else {
  // fallback to macro
  microTimerFunc = macroTimerFunc
}

從上邊精簡之后的代碼，我們可以看到microTimerFunc的實現思路。如果支持瀏覽器支持promise，就用promise實現。如果不支持，就降低到用macroTimerFunc

over，整體邏輯就是這樣。。看著嚇人，掰開了之后好好分析一下，還是挺簡單的。