vue源碼學習-_update

vue之_update()

前言

vue在調用$mount方法的時候會調用mountComponent ,通過vm.render可以得到vnode，得到vnode之后，在mount的時，會調用_update方法，那么_update方法主要是用來做些什么事情呢？

export function mountComponent (
  vm: Component,
  el: ?Element,
  hydrating?: boolean
): Component {
  vm.$el = el
  if (!vm.$options.render) {
    vm.$options.render = createEmptyVNode
    if (process.env.NODE_ENV !== 'production') {
      /* istanbul ignore if */
      if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
        vm.$options.el || el) {
        warn(
          'You are using the runtime-only build of Vue where the template ' +
          'compiler is not available. Either pre-compile the templates into ' +
          'render functions, or use the compiler-included build.',
          vm
        )
      } else {
        warn(
          'Failed to mount component: template or render function not defined.',
          vm
        )
      }
    }
  }
  callHook(vm, 'beforeMount')

  let updateComponent
  /* istanbul ignore if */
  if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
    updateComponent = () => {
      const name = vm._name
      const id = vm._uid
      const startTag = `vue-perf-start:${id}`
      const endTag = `vue-perf-end:${id}`

      mark(startTag)
      const vnode = vm._render()
      mark(endTag)
      measure(`vue ${name} render`, startTag, endTag)

      mark(startTag)
      vm._update(vnode, hydrating)
      mark(endTag)
      measure(`vue ${name} patch`, startTag, endTag)
    }
  } else {
    updateComponent = () => {
      vm._update(vm._render(), hydrating)
    }
  }

_update方法

Vue的_update方法是實例上的一個私有方法，主要作用是把VNode渲染成真實的dom，它在首次渲染和數據更新的時候被調用。在數據更新的時候會發生VNode和舊VNode對比，獲取差異更新視圖，我們常說的diff就是發生在此過程中。

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不存在，表示首次渲染，即初始化頁面時走這里
      // initial render
      vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */)
    } else {
      // 響應式數據更新時，即更新頁面時走這里
      // updates
      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.
  }

__patch__方法

// src/platforms/web/runtime/index.js
// web 平台的patch函數，不同平台的定義不同
Vue.prototype.__patch__ = inBrowser ? patch : noop

patch方法

// src/platforms/web/runtime/patch.js
import * as nodeOps from 'web/runtime/node-ops'
import { createPatchFunction } from 'core/vdom/patch'
import baseModules from 'core/vdom/modules/index'
import platformModules from 'web/runtime/modules/index'

// the directive module should be applied last, after all
// built-in modules have been applied.
const modules = platformModules.concat(baseModules)

// 傳入平台特有的一些操作，然后返回一個 patch 函數
export const patch: Function = createPatchFunction({ nodeOps, modules })

patch是createPatchFunction的返回值，這里傳入了一個對象，nodeOps封裝了一系列相關平台DOM的一些操作方法，modules表示平台特有的一些操作，比如attr,class,style,event等，還有核心的directive和ref，它們會想外暴露一些特有的方法。這里不做贅述。

createPatchFunction

// src/core/vdom/patch.js
const hooks = ['create', 'activate', 'update', 'remove', 'destroy']
/**
 * 傳入相關平台一些功能操作，最后返回 patch 函數
 */
export function createPatchFunction (backend) {
  let i, j
  const cbs = {}

  const { modules, nodeOps } = backend
  /**
   * hooks = ['create', 'activate', 'update', 'remove', 'destroy']
   * 遍歷這些鈎子，然后從 modules 的各個模塊中找到相應的方法，比如：directives 中的 create、update、destroy 方法
   *  cbs[hook] = [hook 方法]，比如: cbs.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]])
      }
    }
  }
  
  /**
   * ...這里定義了一大堆輔助函數，下面用到了撿重點看一下，不一一描述了。
   */
  
  /**
   * @param oldVnode  舊節點，可以不存在或是一個 DOM 對象
   * @param vnode  新節點，_render 返回的節點
   * @param hydrating  是否是服務端渲染
   * @param removeOnly  是給 transition-group 用的
   */
  return function patch (oldVnode, vnode, hydrating, removeOnly) {
    // 新節點不存在，舊節點存在，表示移除，銷毀舊節點。
    if (isUndef(vnode)) {
      if (isDef(oldVnode)) invokeDestroyHook(oldVnode)
      return
    }
    let isInitialPatch = false
    const insertedVnodeQueue = []
    if (isUndef(oldVnode)) {
      // 新節點存在，舊節點不存在，表示新增。
      isInitialPatch = true
      createElm(vnode, insertedVnodeQueue)
    } else {
      // 新舊節點都存在
      
      // 舊節點是否為真實的元素
      const isRealElement = isDef(oldVnode.nodeType)
      if (!isRealElement && sameVnode(oldVnode, vnode)) {
        // patch existing root node
        // 都存在，舊節點不是真實元素且新舊節點是同一節點，表示修改 去做對比
        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.'
              )
            }
          }
          // either not server-rendered, or hydration failed.
          // create an empty node and replace it
          // 不是服務端渲染或服務端渲染失敗，把 oldVnode 轉換成 VNode 對象.
          oldVnode = emptyNodeAt(oldVnode)
        }
        // replacing existing element
        // 舊節點的真實元素
        const oldElm = oldVnode.elm
        // 舊節點的父元素
        const parentElm = nodeOps.parentNode(oldElm)
        // create new node
        // 通過虛擬節點創建真實的元素並插入到它的父節點中
        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)
        )
        // update parent placeholder node element, recursively
        // 遞歸更新父占位符節點元素（異步組件）
        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
          }
        }
        // destroy old node
        // 移除舊節點
        if (isDef(parentElm)) {
          removeVnodes([oldVnode], 0, 0)
        } else if (isDef(oldVnode.tag)) {
          invokeDestroyHook(oldVnode)
        }
      }
    }
    invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch)
    return vnode.elm
  }
}

從createPatchFunction返回的patch方法來看，主要分為這么幾種情況做處理:

• 新節點不存在，舊節點存在，表示移除。
• 新節點存在，舊節點不存在，表示新增
• 新舊節點都存在，舊節點不是真實的元素且新舊節點是同一節點，表示修改(更新)。
• 新舊節點都存在，舊節點是真實的元素，一般是初始化渲染，舊節點的真實DOM也就是傳入進來的vm.$el對應的元素，比如<div id="app">；這里還有一個情況就是當vnode.parent存在，又不是同一節點，表示替換(更新)，比如異步組件

移除節點

// src/core/vdom/patch.js
/**
* 執行組件的destroy鈎子，即執行$destroy方法
* 執行組件各個模塊(style、class、directive等)的destroy方法
* 如果vnode還存在子節點，則遞歸調用
*/
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])
    }
  }
}

初始化

在createPatchFunction中的patch方法內，由於傳入的vm.$el，實際上是一個真實的DOM，所以isRealElement為true，（服務端渲染先跳過）然后通過emptyNodeAt把oldVnode轉換成VNode對象。

emptyNodeAt

// src/core/vdom/patch.js
function emptyNodeAt (elm) {
  return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm)
}

createElm

然后調用createElm方法，這個是重點:

// src/core/vdom/patch.js
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
  // 獲取子VNode
  const children = vnode.children
  // 判斷 tag
  const tag = vnode.tag
  if (isDef(tag)) {
   // 如有有 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)
    /* istanbul ignore if */
    if (__WEEX__) {
      // in Weex, the default insertion order is parent-first.
      // List items can be optimized to use children-first insertion
      // with append="tree".
      const appendAsTree = isDef(data) && isTrue(data.appendAsTree)
      if (!appendAsTree) {
        if (isDef(data)) {
          invokeCreateHooks(vnode, insertedVnodeQueue)
        }
        insert(parentElm, vnode.elm, refElm)
      }
      createChildren(vnode, children, insertedVnodeQueue)
      if (appendAsTree) {
        if (isDef(data)) {
          invokeCreateHooks(vnode, insertedVnodeQueue)
        }
        insert(parentElm, vnode.elm, refElm)
      }
    } else {
      // 遞歸創建所有子節點（普通元素、組件）
      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)
  }
}

createElm的作用就是通過VNode創建真實的DOM插入到父節點中，它首先會執行createComponent方法，這個方法是用來創建子組件的，在初始化的時候會返回false，后面組件新增的時候再看這個方法。然后會對判斷vnode.tag，如果存在的話，會走入下面的邏輯。

vnode.elm = vnode.ns
? nodeOps.createElementNS(vnode.ns, tag)
: nodeOps.createElement(tag, vnode)

``