Vue 原始碼解讀（12）—— patch

前言

前面我們說到，當元件更新時，例項化渲染 watcher 時傳遞的 updateComponent 方法會被執行：

const updateComponent = () => {
  // 執行 vm._render() 函式，得到 虛擬 VNode，並將 VNode 傳遞給 vm._update 方法，接下來就該到 patch 階段了
  vm._update(vm._render(), hydrating)
}

首先會先執行 vm._render() 函式，得到元件的 VNode，並將 VNode 傳遞給 vm._update 方法，接下來就該進入到 patch 階段了。今天我們就來深入理解元件更新時 patch 的執行過程。

歷史

1.x 版本的 Vue 沒有 VNode 和 diff 演算法，那個版本的 Vue 的核心只有響應式原理：Object.defineProperty、Dep、Watcher。

• Object.defineProperty: 負責資料的攔截。getter 時進行依賴收集，setter 時讓 dep 通知 watcher 去更新

• Dep：Vue data 選項返回的物件，物件的 key 和 dep 一一對應

• Watcher：key 和 watcher 時一對多的關係，元件模版中每使用一次 key 就會生成一個 watcher

<template>
  <div class="wrapper">
    <!-- 模版中每引用一次響應式資料，就會生成一個 watcher -->
    <!-- watcher 1 -->
    <div class="msg1">{{ msg }}</div>
    <!-- watcher 2 -->
    <div class="msg2">{{ msg }}</div>
  </div>
</template>

<script>
export default {
  data() {
    return {
      // 和 dep 一一對應，和 watcher 一 對 多
      msg: 'Hello Vue 1.0'
    }
  }
}
</script>

當資料更新時，dep 通知 watcher 去直接更新 DOM，因為這個版本的 watcher 和 DOM 時一一對應關係，watcher 可以非常明確的知道這個 key 在元件模版中的位置，因此可以做到定向更新，所以它的更新效率是非常高的。

雖然更新效率高，但隨之也產生了嚴重的問題，無法完成一個企業級應用，理由很簡單：當你的頁面足夠複雜時，會包含很多的元件，在這種架構下就意味這一個頁面會產生大量的 watcher，這非常耗資源。

這時就在 Vue 2.0 中通過引入 VNode 和 diff 演算法去解決 1.x 中的問題。將 watcher 的粒度放大，變成一個元件一個 watcher（就是我們說的渲染 watcher），這時候你頁面再大，watcher 也很少，這就解決了複雜頁面 watcher 太多導致效能下降的問題。

當響應式資料更新時，dep 通知 watcher 去更新，這時候問題就來了，Vue 1.x 中 watcher 和 key 一一對應，可以明確知道去更新什麼地方，但是 Vue 2.0 中 watcher 對應的是一整個元件，更新的資料在元件的的什麼位置，watcher 並不知道。這時候就需要 VNode 出來解決問題。

通過引入 VNode，當元件中資料更新時，會為元件生成一個新的 VNode，通過比對新老兩個 VNode，找出不一樣的地方，然後執行 DOM 操作更新發生變化的節點，這個過程就是大家熟知的 diff。

以上就是 Vue 2.0 為什麼會引入 VNode 和 diff 演算法的歷史原因了，也是 Vue 1.x 到 2.x 的一個發展歷程。

目標

• 深入理解 Vue 的 patch 階段，理解其 diff 演算法的原理。

原始碼解讀

入口

/src/core/instance/lifecycle.js

const updateComponent = () => {
  // 執行 vm._render() 函式，得到 VNode，並將 VNode 傳遞給 _update 方法，接下來就該到 patch 階段了
  vm._update(vm._render(), hydrating)
}

vm._update

/src/core/instance/lifecycle.js

/**
 * 頁面首次渲染和後續更新的入口位置，也是 patch 的入口位置 
 */
Vue.prototype._update = function (vnode: VNode, hydrating?: boolean) {
  const vm: Component = this
  // 頁面的掛載點，真實的元素
  const prevEl = vm.$el
  // 老 VNode
  const prevVnode = vm._vnode
  const restoreActiveInstance = setActiveInstance(vm)
  // 新 VNode
  vm._vnode = vnode
  // Vue.prototype.__patch__ is injected in entry points
  // based on the rendering backend used.
  if (!prevVnode) {
    // 老 VNode 不存在，表示首次渲染，即初始化頁面時走這裡
    vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */)
  } else {
    // 響應式資料更新時，即更新頁面時走這裡
    vm.$el = vm.__patch__(prevVnode, vnode)
  }
  restoreActiveInstance()
  // update __vue__ reference
  if (prevEl) {
    prevEl.__vue__ = null
  }
  if (vm.$el) {
    vm.$el.__vue__ = vm
  }
  // if parent is an HOC, update its $el as well
  if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
    vm.$parent.$el = vm.$el
  }
  // updated hook is called by the scheduler to ensure that children are
  // updated in a parent's updated hook.
}

vm.__patch__

/src/platforms/web/runtime/index.js

/ 在 Vue 原型鏈上安裝 web 平臺的 patch 函式
Vue.prototype.__patch__ = inBrowser ? patch : noop

patch

/src/platforms/web/runtime/patch.js

// patch 工廠函式，為其傳入平臺特有的一些操作，然後返回一個 patch 函式
export const patch: Function = createPatchFunction({ nodeOps, modules })

nodeOps

src/platforms/web/runtime/node-ops.js

/**
 * web 平臺的 DOM 操作 API
 */

/**
 * 建立標籤名為 tagName 的元素節點
 */
export function createElement (tagName: string, vnode: VNode): Element {
  // 建立元素節點
  const elm = document.createElement(tagName)
  if (tagName !== 'select') {
    return elm
  }
  // false or null will remove the attribute but undefined will not
  // 如果是 select 元素，則為它設定 multiple 屬性
  if (vnode.data && vnode.data.attrs && vnode.data.attrs.multiple !== undefined) {
    elm.setAttribute('multiple', 'multiple')
  }
  return elm
}

// 建立帶名稱空間的元素節點
export function createElementNS (namespace: string, tagName: string): Element {
  return document.createElementNS(namespaceMap[namespace], tagName)
}

// 建立文字節點
export function createTextNode (text: string): Text {
  return document.createTextNode(text)
}

// 建立註釋節點
export function createComment (text: string): Comment {
  return document.createComment(text)
}

// 在指定節點前插入節點
export function insertBefore (parentNode: Node, newNode: Node, referenceNode: Node) {
  parentNode.insertBefore(newNode, referenceNode)
}

/**
 * 移除指定子節點
 */
export function removeChild (node: Node, child: Node) {
  node.removeChild(child)
}

/**
 * 新增子節點
 */
export function appendChild (node: Node, child: Node) {
  node.appendChild(child)
}

/**
 * 返回指定節點的父節點
 */
export function parentNode (node: Node): ?Node {
  return node.parentNode
}

/**
 * 返回指定節點的下一個兄弟節點
 */
export function nextSibling (node: Node): ?Node {
  return node.nextSibling
}

/**
 * 返回指定節點的標籤名 
 */
export function tagName (node: Element): string {
  return node.tagName
}

/**
 * 為指定節點設定文字 
 */
export function setTextContent (node: Node, text: string) {
  node.textContent = text
}

/**
 * 為節點設定指定的 scopeId 屬性，屬性值為 ''
 */
export function setStyleScope (node: Element, scopeId: string) {
  node.setAttribute(scopeId, '')
}

modules

/src/platforms/web/runtime/modules 和 /src/core/vdom/modules

平臺特有的一些操作，比如：attr、class、style、event 等，還有核心的 directive 和 ref，它們會向外暴露一些特有的方法，比如：create、activate、update、remove、destroy，這些方法在 patch 階段時會被呼叫，從而做相應的操作，比如 建立 attr、指令等。這部分內容太多了，這裡就不一一列舉了，在閱讀 patch 的過程中如有需要可回頭深入閱讀，比如操作節點的屬性的時候，就去讀 attr 相關的程式碼。

createPatchFunction

提示：由於該函式的程式碼量較大， 所以調整了一下程式碼結構，方便閱讀和理解

/src/core/vdom/patch.js

const hooks = ['create', 'activate', 'update', 'remove', 'destroy']

/**
 * 工廠函式，注入平臺特有的一些功能操作，並定義一些方法，然後返回 patch 函式
 */
export function createPatchFunction (backend) {
  let i, j
  const cbs = {}

  /**
   * modules: { ref, directives, 平臺特有的一些操縱，比如 attr、class、style 等 }
   * nodeOps: { 對元素的增刪改查 API }
   */
  const { modules, nodeOps } = backend

  /**
   * hooks = ['create', 'activate', 'update', 'remove', 'destroy']
   * 遍歷這些鉤子，然後從 modules 的各個模組中找到相應的方法，比如：directives 中的 create、update、destroy 方法
   * 讓這些方法放到 cb[hook] = [hook 方法] 中，比如: cb.create = [fn1, fn2, ...]
   * 然後在合適的時間呼叫相應的鉤子方法完成對應的操作
   */
  for (i = 0; i < hooks.length; ++i) {
    // 比如 cbs.create = []
    cbs[hooks[i]] = []
    for (j = 0; j < modules.length; ++j) {
      if (isDef(modules[j][hooks[i]])) {
        // 遍歷各個 modules，找出各個 module 中的 create 方法，然後新增到 cbs.create 陣列中
        cbs[hooks[i]].push(modules[j][hooks[i]])
      }
    }
  }
  /**
   * vm.__patch__
   *   1、新節點不存在，老節點存在，呼叫 destroy，銷燬老節點
   *   2、如果 oldVnode 是真實元素，則表示首次渲染，建立新節點，並插入 body，然後移除老節點
   *   3、如果 oldVnode 不是真實元素，則表示更新階段，執行 patchVnode
   */
  return patch
}

patch

src/core/vdom/patch.js

/**
 * vm.__patch__
 *   1、新節點不存在，老節點存在，呼叫 destroy，銷燬老節點
 *   2、如果 oldVnode 是真實元素，則表示首次渲染，建立新節點，並插入 body，然後移除老節點
 *   3、如果 oldVnode 不是真實元素，則表示更新階段，執行 patchVnode
 */
function patch(oldVnode, vnode, hydrating, removeOnly) {
  // 如果新節點不存在，老節點存在，則呼叫 destroy，銷燬老節點
  if (isUndef(vnode)) {
    if (isDef(oldVnode)) invokeDestroyHook(oldVnode)
    return
  }

  let isInitialPatch = false
  const insertedVnodeQueue = []

  if (isUndef(oldVnode)) {
    // 新的 VNode 存在，老的 VNode 不存在，這種情況會在一個元件初次渲染的時候出現，比如：
    // <div id="app"><comp></comp></div>
    // 這裡的 comp 元件初次渲染時就會走這兒
    // empty mount (likely as component), create new root element
    isInitialPatch = true
    createElm(vnode, insertedVnodeQueue)
  } else {
    // 判斷 oldVnode 是否為真實元素
    const isRealElement = isDef(oldVnode.nodeType)
    if (!isRealElement && sameVnode(oldVnode, vnode)) {
      // 不是真實元素，但是老節點和新節點是同一個節點，則是更新階段，執行 patch 更新節點
      patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly)
    } else {
      // 是真實元素，則表示初次渲染
      if (isRealElement) {
        // 掛載到真實元素以及處理服務端渲染的情況
        // mounting to a real element
        // check if this is server-rendered content and if we can perform
        // a successful hydration.
        if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
          oldVnode.removeAttribute(SSR_ATTR)
          hydrating = true
        }
        if (isTrue(hydrating)) {
          if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
            invokeInsertHook(vnode, insertedVnodeQueue, true)
            return oldVnode
          } else if (process.env.NODE_ENV !== 'production') {
            warn(
              'The client-side rendered virtual DOM tree is not matching ' +
              'server-rendered content. This is likely caused by incorrect ' +
              'HTML markup, for example nesting block-level elements inside ' +
              '<p>, or missing <tbody>. Bailing hydration and performing ' +
              'full client-side render.'
            )
          }
        }
        // 走到這兒說明不是服務端渲染，或者 hydration 失敗，則根據 oldVnode 建立一個 vnode 節點
        // either not server-rendered, or hydration failed.
        // create an empty node and replace it
        oldVnode = emptyNodeAt(oldVnode)
      }

      // 拿到老節點的真實元素
      const oldElm = oldVnode.elm
      // 獲取老節點的父元素，即 body
      const parentElm = nodeOps.parentNode(oldElm)

      // 基於新 vnode 建立整棵 DOM 樹並插入到 body 元素下
      createElm(
        vnode,
        insertedVnodeQueue,
        // extremely rare edge case: do not insert if old element is in a
        // leaving transition. Only happens when combining transition +
        // keep-alive + HOCs. (#4590)
        oldElm._leaveCb ? null : parentElm,
        nodeOps.nextSibling(oldElm)
      )

      // 遞迴更新父佔位符節點元素
      if (isDef(vnode.parent)) {
        let ancestor = vnode.parent
        const patchable = isPatchable(vnode)
        while (ancestor) {
          for (let i = 0; i < cbs.destroy.length; ++i) {
            cbs.destroy[i](ancestor)
          }
          ancestor.elm = vnode.elm
          if (patchable) {
            for (let i = 0; i < cbs.create.length; ++i) {
              cbs.create[i](emptyNode, ancestor)
            }
            // #6513
            // invoke insert hooks that may have been merged by create hooks.
            // e.g. for directives that uses the "inserted" hook.
            const insert = ancestor.data.hook.insert
            if (insert.merged) {
              // start at index 1 to avoid re-invoking component mounted hook
              for (let i = 1; i < insert.fns.length; i++) {
                insert.fns[i]()
              }
            }
          } else {
            registerRef(ancestor)
          }
          ancestor = ancestor.parent
        }
      }

      // 移除老節點
      if (isDef(parentElm)) {
        removeVnodes([oldVnode], 0, 0)
      } else if (isDef(oldVnode.tag)) {
        invokeDestroyHook(oldVnode)
      }
    }
  }

  invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch)
  return vnode.elm
}

invokeDestroyHook

src/core/vdom/patch.js

/**
 * 銷燬節點：
 *   執行元件的 destroy 鉤子，即執行 $destroy 方法 
 *   執行元件各個模組(style、class、directive 等）的 destroy 方法
 *   如果 vnode 還存在子節點，則遞迴呼叫 invokeDestroyHook
 */
function invokeDestroyHook(vnode) {
  let i, j
  const data = vnode.data
  if (isDef(data)) {
    if (isDef(i = data.hook) && isDef(i = i.destroy)) i(vnode)
    for (i = 0; i < cbs.destroy.length; ++i) cbs.destroy[i](vnode)
  }
  if (isDef(i = vnode.children)) {
    for (j = 0; j < vnode.children.length; ++j) {
      invokeDestroyHook(vnode.children[j])
    }
  }
}

sameVnode

src/core/vdom/patch.js

/**
 * 判讀兩個節點是否相同 
 */
function sameVnode (a, b) {
  return (
    // key 必須相同，需要注意的是 undefined === undefined => true
    a.key === b.key && (
      (
        // 標籤相同
        a.tag === b.tag &&
        // 都是註釋節點
        a.isComment === b.isComment &&
        // 都有 data 屬性
        isDef(a.data) === isDef(b.data) &&
        // input 標籤的情況
        sameInputType(a, b)
      ) || (
        // 非同步佔位符節點
        isTrue(a.isAsyncPlaceholder) &&
        a.asyncFactory === b.asyncFactory &&
        isUndef(b.asyncFactory.error)
      )
    )
  )
}

emptyNodeAt

src/core/vdom/patch.js

/**
 * 為元素(elm)建立一個空的 vnode
 */
function emptyNodeAt(elm) {
  return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm)
}

createElm

src/core/vdom/patch.js

/**
 * 基於 vnode 建立整棵 DOM 樹，並插入到父節點上
 */
function createElm(
  vnode,
  insertedVnodeQueue,
  parentElm,
  refElm,
  nested,
  ownerArray,
  index
) {
  if (isDef(vnode.elm) && isDef(ownerArray)) {
    // This vnode was used in a previous render!
    // now it's used as a new node, overwriting its elm would cause
    // potential patch errors down the road when it's used as an insertion
    // reference node. Instead, we clone the node on-demand before creating
    // associated DOM element for it.
    vnode = ownerArray[index] = cloneVNode(vnode)
  }

  vnode.isRootInsert = !nested // for transition enter check
  /**
   * 重點
   * 1、如果 vnode 是一個元件，則執行 init 鉤子，建立元件例項並掛載，
   *   然後為元件執行各個模組的 create 鉤子
   *   如果元件被 keep-alive 包裹，則啟用元件
   * 2、如果是一個普通元素，則什麼也不錯
   */
  if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
    return
  }

  // 獲取 data 物件
  const data = vnode.data
  // 所有的孩子節點
  const children = vnode.children
  const tag = vnode.tag
  if (isDef(tag)) {
    // 未知標籤
    if (process.env.NODE_ENV !== 'production') {
      if (data && data.pre) {
        creatingElmInVPre++
      }
      if (isUnknownElement(vnode, creatingElmInVPre)) {
        warn(
          'Unknown custom element: <' + tag + '> - did you ' +
          'register the component correctly? For recursive components, ' +
          'make sure to provide the "name" option.',
          vnode.context
        )
      }
    }

    // 建立新節點
    vnode.elm = vnode.ns
      ? nodeOps.createElementNS(vnode.ns, tag)
      : nodeOps.createElement(tag, vnode)
    setScope(vnode)

    // 遞迴建立所有子節點（普通元素、元件）
    createChildren(vnode, children, insertedVnodeQueue)
    if (isDef(data)) {
      invokeCreateHooks(vnode, insertedVnodeQueue)
    }
    // 將節點插入父節點
    insert(parentElm, vnode.elm, refElm)

    if (process.env.NODE_ENV !== 'production' && data && data.pre) {
      creatingElmInVPre--
    }
  } else if (isTrue(vnode.isComment)) {
    // 註釋節點，建立註釋節點並插入父節點
    vnode.elm = nodeOps.createComment(vnode.text)
    insert(parentElm, vnode.elm, refElm)
  } else {
    // 文字節點，建立文字節點並插入父節點
    vnode.elm = nodeOps.createTextNode(vnode.text)
    insert(parentElm, vnode.elm, refElm)
  }
}

createComponent

src/core/vdom/patch.js

/**
 * 如果 vnode 是一個元件，則執行 init 鉤子，建立元件例項，並掛載
 * 然後為元件執行各個模組的 create 方法
 * @param {*} vnode 元件新的 vnode
 * @param {*} insertedVnodeQueue 陣列
 * @param {*} parentElm oldVnode 的父節點
 * @param {*} refElm oldVnode 的下一個兄弟節點
 * @returns 如果 vnode 是一個元件並且元件建立成功，則返回 true，否則返回 undefined
 */
function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
  // 獲取 vnode.data 物件
  let i = vnode.data
  if (isDef(i)) {
    // 驗證元件例項是否已經存在 && 被 keep-alive 包裹
    const isReactivated = isDef(vnode.componentInstance) && i.keepAlive
    // 執行 vnode.data.init 鉤子函式，該函式在講 render helper 時講過
    // 如果是被 keep-alive 包裹的元件：則再執行 prepatch 鉤子，用 vnode 上的各個屬性更新 oldVnode 上的相關屬性
    // 如果是元件沒有被 keep-alive 包裹或者首次渲染，則初始化元件，並進入掛載階段
    if (isDef(i = i.hook) && isDef(i = i.init)) {
      i(vnode, false /* hydrating */)
    }
    // after calling the init hook, if the vnode is a child component
    // it should've created a child instance and mounted it. the child
    // component also has set the placeholder vnode's elm.
    // in that case we can just return the element and be done.
    if (isDef(vnode.componentInstance)) {
      // 如果 vnode 是一個子元件，則呼叫 init 鉤子之後會建立一個元件例項，並掛載
      // 這時候就可以給元件執行各個模組的的 create 鉤子了
      initComponent(vnode, insertedVnodeQueue)
      // 將元件的 DOM 節點插入到父節點內
      insert(parentElm, vnode.elm, refElm)
      if (isTrue(isReactivated)) {
        // 元件被 keep-alive 包裹的情況，啟用元件
        reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm)
      }
      return true
    }
  }
}

insert

src/core/vdom/patch.js

/**
 * 向父節點插入節點 
 */
function insert(parent, elm, ref) {
  if (isDef(parent)) {
    if (isDef(ref)) {
      if (nodeOps.parentNode(ref) === parent) {
        nodeOps.insertBefore(parent, elm, ref)
      }
    } else {
      nodeOps.appendChild(parent, elm)
    }
  }
}

removeVnodes

src/core/vdom/patch.js

/**
 * 移除指定索引範圍（startIdx —— endIdx）內的節點 
 */
function removeVnodes(vnodes, startIdx, endIdx) {
  for (; startIdx <= endIdx; ++startIdx) {
    const ch = vnodes[startIdx]
    if (isDef(ch)) {
      if (isDef(ch.tag)) {
        removeAndInvokeRemoveHook(ch)
        invokeDestroyHook(ch)
      } else { // Text node
        removeNode(ch.elm)
      }
    }
  }
}

patchVnode

src/core/vdom/patch.js

/**
 * 更新節點
 *   全量的屬性更新
 *   如果新老節點都有孩子，則遞迴執行 diff
 *   如果新節點有孩子，老節點沒孩子，則新增新節點的這些孩子節點
 *   如果老節點有孩子，新節點沒孩子，則刪除老節點的這些孩子
 *   更新文字節點
 */
function patchVnode(
  oldVnode,
  vnode,
  insertedVnodeQueue,
  ownerArray,
  index,
  removeOnly
) {
  // 老節點和新節點相同，直接返回
  if (oldVnode === vnode) {
    return
  }

  if (isDef(vnode.elm) && isDef(ownerArray)) {
    // clone reused vnode
    vnode = ownerArray[index] = cloneVNode(vnode)
  }

  const elm = vnode.elm = oldVnode.elm

  // 非同步佔位符節點
  if (isTrue(oldVnode.isAsyncPlaceholder)) {
    if (isDef(vnode.asyncFactory.resolved)) {
      hydrate(oldVnode.elm, vnode, insertedVnodeQueue)
    } else {
      vnode.isAsyncPlaceholder = true
    }
    return
  }

  // 跳過靜態節點的更新
  // reuse element for static trees.
  // note we only do this if the vnode is cloned -
  // if the new node is not cloned it means the render functions have been
  // reset by the hot-reload-api and we need to do a proper re-render.
  if (isTrue(vnode.isStatic) &&
    isTrue(oldVnode.isStatic) &&
    vnode.key === oldVnode.key &&
    (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))
  ) {
    // 新舊節點都是靜態的而且兩個節點的 key 一樣，並且新節點被 clone 了 或者 新節點有 v-once指令，則重用這部分節點
    vnode.componentInstance = oldVnode.componentInstance
    return
  }

  // 執行元件的 prepatch 鉤子
  let i
  const data = vnode.data
  if (isDef(data) && isDef(i = data.hook) && isDef(i = i.prepatch)) {
    i(oldVnode, vnode)
  }

  // 老節點的孩子
  const oldCh = oldVnode.children
  // 新節點的孩子
  const ch = vnode.children
  // 全量更新新節點的屬性，Vue 3.0 在這裡做了很多的優化
  if (isDef(data) && isPatchable(vnode)) {
    // 執行新節點所有的屬性更新
    for (i = 0; i < cbs.update.length; ++i) cbs.update[i](oldVnode, vnode)
    if (isDef(i = data.hook) && isDef(i = i.update)) i(oldVnode, vnode)
  }
  if (isUndef(vnode.text)) {
    // 新節點不是文字節點
    if (isDef(oldCh) && isDef(ch)) {
      // 如果新老節點都有孩子，則遞迴執行 diff 過程
      if (oldCh !== ch) updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly)
    } else if (isDef(ch)) {
      // 老孩子不存在，新孩子存在，則建立這些新孩子節點
      if (process.env.NODE_ENV !== 'production') {
        checkDuplicateKeys(ch)
      }
      if (isDef(oldVnode.text)) nodeOps.setTextContent(elm, '')
      addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue)
    } else if (isDef(oldCh)) {
      // 老孩子存在，新孩子不存在，則移除這些老孩子節點
      removeVnodes(oldCh, 0, oldCh.length - 1)
    } else if (isDef(oldVnode.text)) {
      // 老節點是文字節點，則將文字內容置空
      nodeOps.setTextContent(elm, '')
    }
  } else if (oldVnode.text !== vnode.text) {
    // 新節點是文字節點，則更新文字節點
    nodeOps.setTextContent(elm, vnode.text)
  }
  if (isDef(data)) {
    if (isDef(i = data.hook) && isDef(i = i.postpatch)) i(oldVnode, vnode)
  }
}

updateChildren

src/core/vdom/patch.js

/**
 * diff 過程:
 *   diff 優化：做了四種假設，假設新老節點開頭結尾有相同節點的情況，一旦命中假設，就避免了一次迴圈，以提高執行效率
 *             如果不幸沒有命中假設，則執行遍歷，從老節點中找到新開始節點
 *             找到相同節點，則執行 patchVnode，然後將老節點移動到正確的位置
 *   如果老節點先於新節點遍歷結束，則剩餘的新節點執行新增節點操作
 *   如果新節點先於老節點遍歷結束，則剩餘的老節點執行刪除操作，移除這些老節點
 */
function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
  // 老節點的開始索引
  let oldStartIdx = 0
  // 新節點的開始索引
  let newStartIdx = 0
  // 老節點的結束索引
  let oldEndIdx = oldCh.length - 1
  // 第一個老節點
  let oldStartVnode = oldCh[0]
  // 最後一個老節點
  let oldEndVnode = oldCh[oldEndIdx]
  // 新節點的結束索引
  let newEndIdx = newCh.length - 1
  // 第一個新節點
  let newStartVnode = newCh[0]
  // 最後一個新節點
  let newEndVnode = newCh[newEndIdx]
  let oldKeyToIdx, idxInOld, vnodeToMove, refElm

  // removeOnly是一個特殊的標誌，僅由 <transition-group> 使用，以確保被移除的元素在離開轉換期間保持在正確的相對位置
  const canMove = !removeOnly

  if (process.env.NODE_ENV !== 'production') {
    // 檢查新節點的 key 是否重複
    checkDuplicateKeys(newCh)
  }

  // 遍歷新老兩組節點，只要有一組遍歷完（開始索引超過結束索引）則跳出迴圈
  while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
    if (isUndef(oldStartVnode)) {
      // 如果節點被移動，在當前索引上可能不存在，檢測這種情況，如果節點不存在則調整索引
      oldStartVnode = oldCh[++oldStartIdx] // Vnode has been moved left
    } else if (isUndef(oldEndVnode)) {
      oldEndVnode = oldCh[--oldEndIdx]
    } else if (sameVnode(oldStartVnode, newStartVnode)) {
      // 老開始節點和新開始節點是同一個節點，執行 patch
      patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx)
      // patch 結束後老開始和新開始的索引分別加 1
      oldStartVnode = oldCh[++oldStartIdx]
      newStartVnode = newCh[++newStartIdx]
    } else if (sameVnode(oldEndVnode, newEndVnode)) {
      // 老結束和新結束是同一個節點，執行 patch
      patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx)
      // patch 結束後老結束和新結束的索引分別減 1
      oldEndVnode = oldCh[--oldEndIdx]
      newEndVnode = newCh[--newEndIdx]
    } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right
      // 老開始和新結束是同一個節點，執行 patch
      patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx)
      // 處理被 transtion-group 包裹的元件時使用
      canMove && nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm))
      // patch 結束後老開始索引加 1，新結束索引減 1
      oldStartVnode = oldCh[++oldStartIdx]
      newEndVnode = newCh[--newEndIdx]
    } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left
      // 老結束和新開始是同一個節點，執行 patch
      patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx)
      canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm)
      // patch 結束後，老結束的索引減 1，新開始的索引加 1
      oldEndVnode = oldCh[--oldEndIdx]
      newStartVnode = newCh[++newStartIdx]
    } else {
      // 如果上面的四種假設都不成立，則通過遍歷找到新開始節點在老節點中的位置索引

      // 找到老節點中每個節點 key 和 索引之間的關係對映 => oldKeyToIdx = { key1: idx1, ... }
      if (isUndef(oldKeyToIdx)) oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx)
      // 在對映中找到新開始節點在老節點中的位置索引
      idxInOld = isDef(newStartVnode.key)
        ? oldKeyToIdx[newStartVnode.key]
        : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx)
      if (isUndef(idxInOld)) { // New element
        // 在老節點中沒找到新開始節點，則說明是新建立的元素，執行建立
        createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx)
      } else {
        // 在老節點中找到新開始節點了
        vnodeToMove = oldCh[idxInOld]
        if (sameVnode(vnodeToMove, newStartVnode)) {
          // 如果這兩個節點是同一個，則執行 patch
          patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx)
          // patch 結束後將該老節點置為 undefined
          oldCh[idxInOld] = undefined
          canMove && nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm)
        } else {
          // 最後這種情況是，找到節點了，但是發現兩個節點不是同一個節點，則視為新元素，執行建立
          createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx)
        }
      }
      // 老節點向後移動一個
      newStartVnode = newCh[++newStartIdx]
    }
  }
  // 走到這裡，說明老姐節點或者新節點被遍歷完了
  if (oldStartIdx > oldEndIdx) {
    // 說明老節點被遍歷完了，新節點有剩餘，則說明這部分剩餘的節點是新增的節點，然後新增這些節點
    refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm
    addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue)
  } else if (newStartIdx > newEndIdx) {
    // 說明新節點被遍歷完了，老節點有剩餘，說明這部分的節點被刪掉了，則移除這些節點
    removeVnodes(oldCh, oldStartIdx, oldEndIdx)
  }
}

checkDuplicateKeys

src/core/vdom/patch.js

/**
 * 檢查一組元素的 key 是否重複 
 */
function checkDuplicateKeys(children) {
  const seenKeys = {}
  for (let i = 0; i < children.length; i++) {
    const vnode = children[i]
    const key = vnode.key
    if (isDef(key)) {
      if (seenKeys[key]) {
        warn(
          `Duplicate keys detected: '${key}'. This may cause an update error.`,
          vnode.context
        )
      } else {
        seenKeys[key] = true
      }
    }
  }
}

addVnodes

src/core/vdom/patch.js

/**
 * 在指定索引範圍（startIdx —— endIdx）內新增節點
 */
function addVnodes(parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
  for (; startIdx <= endIdx; ++startIdx) {
    createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx)
  }
}

createKeyToOldIdx

src/core/vdom/patch.js

/**
 * 得到指定範圍（beginIdx —— endIdx）內節點的 key 和 索引之間的關係對映 => { key1: idx1, ... }
 */
function createKeyToOldIdx(children, beginIdx, endIdx) {
  let i, key
  const map = {}
  for (i = beginIdx; i <= endIdx; ++i) {
    key = children[i].key
    if (isDef(key)) map[key] = i
  }
  return map
}

findIdxInOld

src/core/vdom/patch.js

/**
  * 找到新節點（vnode）在老節點（oldCh）中的位置索引 
  */
function findIdxInOld(node, oldCh, start, end) {
  for (let i = start; i < end; i++) {
    const c = oldCh[i]
    if (isDef(c) && sameVnode(node, c)) return i
  }
}

invokeCreateHooks

src/core/vdom/patch.js

/**
 * 呼叫 各個模組的 create 方法，比如建立屬性的、建立樣式的、指令的等等 ，然後執行元件的 mounted 生命週期方法
 */
function invokeCreateHooks(vnode, insertedVnodeQueue) {
  for (let i = 0; i < cbs.create.length; ++i) {
    cbs.create[i](emptyNode, vnode)
  }
  // 元件鉤子
  i = vnode.data.hook // Reuse variable
  if (isDef(i)) {
    // 元件好像沒有 create 鉤子
    if (isDef(i.create)) i.create(emptyNode, vnode)
    // 呼叫元件的 insert 鉤子，執行元件的 mounted 生命週期方法
    if (isDef(i.insert)) insertedVnodeQueue.push(vnode)
  }
}

createChildren

src/core/vdom/patch.js

/**
 * 建立所有子節點，並將子節點插入父節點，形成一棵 DOM 樹
 */
function createChildren(vnode, children, insertedVnodeQueue) {
  if (Array.isArray(children)) {
    // children 是陣列，表示是一組節點
    if (process.env.NODE_ENV !== 'production') {
      // 檢測這組節點的 key 是否重複
      checkDuplicateKeys(children)
    }
    // 遍歷這組節點，依次建立這些節點然後插入父節點，形成一棵 DOM 樹
    for (let i = 0; i < children.length; ++i) {
      createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i)
    }
  } else if (isPrimitive(vnode.text)) {
    // 說明是文字節點，建立文字節點，並插入父節點
    nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)))
  }
}

總結

• 面試官 問：你能說一說 Vue 的 patch 演算法嗎？

  答：

  Vue 的 patch 演算法有三個作用：負責首次渲染和後續更新或者銷燬元件

  • 如果老的 VNode 是真實元素，則表示首次渲染，建立整棵 DOM 樹，並插入 body，然後移除老的模版節點

  • 如果老的 VNode 不是真實元素，並且新的 VNode 也存在，則表示更新階段，執行 patchVnode

    • 首先是全量更新所有的屬性

    • 如果新老 VNode 都有孩子，則遞迴執行 updateChildren，進行 diff 過程

      針對前端操作 DOM 節點的特點進行如下優化：

      • 同層比較（降低時間複雜度）深度優先（遞迴）

      • 而且前端很少有完全打亂節點順序的情況，所以做了四種假設，假設新老 VNode 的開頭結尾存在相同節點，一旦命中假設，就避免了一次迴圈，降低了 diff 的時間複雜度，提高執行效率。如果不幸沒有命中假設，則執行遍歷，從老的 VNode 中找到新的 VNode 的開始節點

      • 找到相同節點，則執行 patchVnode，然後將老節點移動到正確的位置

      • 如果老的 VNode 先於新的 VNode 遍歷結束，則剩餘的新的 VNode 執行新增節點操作

      • 如果新的 VNode 先於老的 VNode 遍歷結束，則剩餘的老的 VNode 執行刪除操縱，移除這些老節點

    • 如果新的 VNode 有孩子，老的 VNode 沒孩子，則新增這些新孩子節點

    • 如果老的 VNode 有孩子，新的 VNode 沒孩子，則刪除這些老孩子節點

    • 剩下一種就是更新文字節點

  • 如果新的 VNode 不存在，老的 VNode 存在，則呼叫 destroy，銷燬老節點

---

好了，到這裡，Vue 原始碼解讀系列就結束了，如果你認認真真的讀完整個系列的文章，相信你對 Vue 原始碼已經相當熟悉了，不論是從巨集觀層面理解，還是某些細節方面的詳解，應該都沒問題。即使有些細節現在不清楚，但是當遇到問題時，你也能一眼看出來該去原始碼的什麼位置去找答案。

到這裡你可以試著在自己的腦海中複述一下 Vue 的整個執行流程。過程很重要，但 總結 才是最後的昇華時刻。如果在哪個環節卡住了，可再回去讀相應的部分就可以了。

還記得系列的第一篇文章中提到的目標嗎？相信閱讀幾遍下來，你一定可以在自己的簡歷中寫到：精通 Vue 框架的原始碼原理。

接下來會開始 Vue 的手寫系列。

連結

• 配套視訊，微信公眾號回覆："精通 Vue 技術棧原始碼原理視訊版" 獲取
• 精通 Vue 技術棧原始碼原理 專欄
• github 倉庫 liyongning/Vue 歡迎 Star

感謝各位的：關注、點贊、收藏和評論，我們下期見。

---

當學習成為了習慣，知識也就變成了常識。 感謝各位的 關注、 點贊、收藏和評論。

新視訊和文章會第一時間在微信公眾號傳送，歡迎關注：李永寧lyn

文章已收錄到 github 倉庫 liyongning/blog，歡迎 Watch 和 Star。