Vue 2.5中怎么實(shí)現(xiàn)一個Diff算法

Vue 2.5中怎么實(shí)現(xiàn)一個Diff算法，相信很多沒有經(jīng)驗(yàn)的人對此束手無策，為此本文總結(jié)了問題出現(xiàn)的原因和解決方法，通過這篇文章希望你能解決這個問題。

1.VNode對象

一個VNode的實(shí)例包含了以下屬性，這部分代碼在src/core/vdom/vnode.js里

export default class VNode {
 tag: string | void;
 data: VNodeData | void;
 children: ?Array<VNode>;
 text: string | void;
 elm: Node | void;
 ns: string | void;
 context: Component | void; // rendered in this component's scope
 key: string | number | void;
 componentOptions: VNodeComponentOptions | void;
 componentInstance: Component | void; // component instance
 parent: VNode | void; // component placeholder node

 // strictly internal
 raw: boolean; // contains raw HTML? (server only)
 isStatic: boolean; // hoisted static node
 isRootInsert: boolean; // necessary for enter transition check
 isComment: boolean; // empty comment placeholder?
 isCloned: boolean; // is a cloned node?
 isOnce: boolean; // is a v-once node?
 asyncFactory: Function | void; // async component factory function
 asyncMeta: Object | void;
 isAsyncPlaceholder: boolean;
 ssrContext: Object | void;
 functionalContext: Component | void; // real context vm for functional nodes
 functionalOptions: ?ComponentOptions; // for SSR caching
 functionalScopeId: ?string; // functioanl scope id support

• tag: 當(dāng)前節(jié)點(diǎn)的標(biāo)簽名

• data: 當(dāng)前節(jié)點(diǎn)的數(shù)據(jù)對象，具體包含哪些字段可以參考vue源碼types/vnode.d.ts中對VNodeData的定義

• children: 數(shù)組類型，包含了當(dāng)前節(jié)點(diǎn)的子節(jié)點(diǎn)

• text: 當(dāng)前節(jié)點(diǎn)的文本，一般文本節(jié)點(diǎn)或注釋節(jié)點(diǎn)會有該屬性

• elm: 當(dāng)前虛擬節(jié)點(diǎn)對應(yīng)的真實(shí)的dom節(jié)點(diǎn)

• ns: 節(jié)點(diǎn)的namespace

• context: 編譯作用域

• functionalContext: 函數(shù)化組件的作用域

• key: 節(jié)點(diǎn)的key屬性，用于作為節(jié)點(diǎn)的標(biāo)識，有利于patch的優(yōu)化

• componentOptions: 創(chuàng)建組件實(shí)例時會用到的選項(xiàng)信息

• child: 當(dāng)前節(jié)點(diǎn)對應(yīng)的組件實(shí)例

• parent: 組件的占位節(jié)點(diǎn)

• raw: raw html

• isStatic: 靜態(tài)節(jié)點(diǎn)的標(biāo)識

• isRootInsert: 是否作為根節(jié)點(diǎn)插入，被

• isComment: 當(dāng)前節(jié)點(diǎn)是否是注釋節(jié)點(diǎn)

• isCloned: 當(dāng)前節(jié)點(diǎn)是否為克隆節(jié)點(diǎn)

• isOnce: 當(dāng)前節(jié)點(diǎn)是否有v-once指令
  

2.VNode的分類

VNode可以理解為VueVirtual Dom的一個基類，通過VNode構(gòu)造函數(shù)生成的VNnode實(shí)例可為如下幾類：

• EmptyVNode: 沒有內(nèi)容的注釋節(jié)點(diǎn)

• TextVNode: 文本節(jié)點(diǎn)

• ElementVNode: 普通元素節(jié)點(diǎn)

• ComponentVNode: 組件節(jié)點(diǎn)

• CloneVNode: 克隆節(jié)點(diǎn)，可以是以上任意類型的節(jié)點(diǎn)，唯一的區(qū)別在于isCloned屬性為true
  

3.Create-Element源碼解析

這部分代碼在src/core/vdom/create-element.js里，我就直接粘代碼加上我的注釋了

export function createElement (
 context: Component,
 tag: any,
 data: any,
 children: any,
 normalizationType: any,
 alwaysNormalize: boolean
): VNode {
 // 兼容不傳data的情況
 if (Array.isArray(data) || isPrimitive(data)) {
 normalizationType = children
 children = data
 data = undefined
 }
 // 如果alwaysNormalize是true
 // 那么normalizationType應(yīng)該設(shè)置為常量ALWAYS_NORMALIZE的值
 if (isTrue(alwaysNormalize)) {
 normalizationType = ALWAYS_NORMALIZE
 }
 // 調(diào)用_createElement創(chuàng)建虛擬節(jié)點(diǎn)
 return _createElement(context, tag, data, children, normalizationType)
}

export function _createElement (
 context: Component,
 tag?: string | Class<Component> | Function | Object,
 data?: VNodeData,
 children?: any,
 normalizationType?: number
): VNode {

 /**
 * 如果存在data.__ob__，說明data是被Observer觀察的數(shù)據(jù)
 * 不能用作虛擬節(jié)點(diǎn)的data
 * 需要拋出警告，并返回一個空節(jié)點(diǎn)
 *
 * 被監(jiān)控的data不能被用作vnode渲染的數(shù)據(jù)的原因是：
 * data在vnode渲染過程中可能會被改變，這樣會觸發(fā)監(jiān)控，導(dǎo)致不符合預(yù)期的操作
 */
 if (isDef(data) && isDef((data: any).__ob__)) {
 process.env.NODE_ENV !== 'production' && warn(
  `Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` +
  'Always create fresh vnode data objects in each render!',
  context
 )
 return createEmptyVNode()
 }
 // object syntax in v-bind
 if (isDef(data) && isDef(data.is)) {
 tag = data.is
 }
 if (!tag) {
 // 當(dāng)組件的is屬性被設(shè)置為一個falsy的值
 // Vue將不會知道要把這個組件渲染成什么
 // 所以渲染一個空節(jié)點(diǎn)
 // in case of component :is set to falsy value
 return createEmptyVNode()
 }
 // key為非原始值警告
 // warn against non-primitive key
 if (process.env.NODE_ENV !== 'production' &&
 isDef(data) && isDef(data.key) && !isPrimitive(data.key)
 ) {
 warn(
  'Avoid using non-primitive value as key, ' +
  'use string/number value instead.',
  context
 )
 }
 // 作用域插槽
 // support single function children as default scoped slot
 if (Array.isArray(children) &&
 typeof children[0] === 'function'
 ) {
 data = data || {}
 data.scopedSlots = { default: children[0] }
 children.length = 0
 }
 // 根據(jù)normalizationType的值，選擇不同的處理方法
 if (normalizationType === ALWAYS_NORMALIZE) {
 children = normalizeChildren(children)
 } else if (normalizationType === SIMPLE_NORMALIZE) {
 children = simpleNormalizeChildren(children)
 }
 let vnode, ns
 // 如果標(biāo)簽名是字符串類型
 if (typeof tag === 'string') {
 let Ctor
 // 獲取標(biāo)簽的命名空間
 ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag)
 // 如果是保留標(biāo)簽
 if (config.isReservedTag(tag)) {
  // platform built-in elements
  // 就創(chuàng)建這樣一個vnode
  vnode = new VNode(
  config.parsePlatformTagName(tag), data, children,
  undefined, undefined, context
  )
  // 如果不是保留字標(biāo)簽，嘗試從vm的components上查找是否有這個標(biāo)簽的定義
 } else if (isDef(Ctor = resolveAsset(context.$options, 'components', tag))) {
  // component
  // 如果找到，就創(chuàng)建虛擬組件節(jié)點(diǎn)
  vnode = createComponent(Ctor, data, context, children, tag)
 } else {
  // unknown or unlisted namespaced elements
  // check at runtime because it may get assigned a namespace when its
  // parent normalizes children
  // 兜底方案，創(chuàng)建一個正常的vnode
  vnode = new VNode(
  tag, data, children,
  undefined, undefined, context
  )
 }
 } else {
 // 當(dāng)tag不是字符串的時候，我們認(rèn)為tag是組件的構(gòu)造類
 // 所以直接創(chuàng)建
 // direct component options / constructor
 vnode = createComponent(tag, data, context, children)
 }
 if (isDef(vnode)) {
 // 應(yīng)用命名空間
 if (ns) applyNS(vnode, ns)
 return vnode
 } else {
 // 返回一個空節(jié)點(diǎn)
 return createEmptyVNode()
 }
}
function applyNS (vnode, ns, force) {
 vnode.ns = ns
 if (vnode.tag === 'foreignObject') {
 // use default namespace inside foreignObject
 ns = undefined
 force = true
 }
 if (isDef(vnode.children)) {
 for (let i = 0, l = vnode.children.length; i < l; i++) {
  const child = vnode.children[i]
  if (isDef(child.tag) && (isUndef(child.ns) || isTrue(force))) {
  applyNS(child, ns, force)
  }
 }
 }
}

4.Patch原理

patch函數(shù)的定義在src/core/vdom/patch.js中，patch邏輯比較簡單，就不粘代碼了

patch函數(shù)接收6個參數(shù)：

• oldVnode: 舊的虛擬節(jié)點(diǎn)或舊的真實(shí)dom節(jié)點(diǎn)

• vnode: 新的虛擬節(jié)點(diǎn)

• hydrating: 是否要跟真是dom混合

• removeOnly: 特殊flag，用于

• parentElm: 父節(jié)點(diǎn)

• refElm: 新節(jié)點(diǎn)將插入到refElm之前

patch的邏輯是：

if vnode不存在但是oldVnode存在，說明意圖是要銷毀老節(jié)點(diǎn)，那么就調(diào)用invokeDestroyHook(oldVnode)來進(jìn)行銷

if oldVnode不存在但是vnode存在，說明意圖是要創(chuàng)建新節(jié)點(diǎn)，那么就調(diào)用createElm來創(chuàng)建新節(jié)點(diǎn)

else 當(dāng)vnode和oldVnode都存在時

if oldVnode和vnode是同一個節(jié)點(diǎn)，就調(diào)用patchVnode來進(jìn)行patch

當(dāng)vnode和oldVnode不是同一個節(jié)點(diǎn)時，如果oldVnode是真實(shí)dom節(jié)點(diǎn)或hydrating設(shè)置為true，需要用hydrate函數(shù)將虛擬dom和真是dom進(jìn)行映射，然后將oldVnode設(shè)置為對應(yīng)的虛擬dom，找到oldVnode.elm的父節(jié)點(diǎn)，根據(jù)vnode創(chuàng)建一個真實(shí)dom節(jié)點(diǎn)并插入到該父節(jié)點(diǎn)中oldVnode.elm的位置

patchVnode的邏輯是：

1.如果oldVnode跟vnode完全一致，那么不需要做任何事情

2.如果oldVnode跟vnode都是靜態(tài)節(jié)點(diǎn)，且具有相同的key，當(dāng)vnode是克隆節(jié)點(diǎn)或是v-once指令控制的節(jié)點(diǎn)時，只需要把oldVnode.elm和oldVnode.child都復(fù)制到vnode上，也不用再有其他操作

3.否則，如果vnode不是文本節(jié)點(diǎn)或注釋節(jié)點(diǎn)

• 如果oldVnode和vnode都有子節(jié)點(diǎn)，且2方的子節(jié)點(diǎn)不完全一致，就執(zhí)行updateChildren

• 如果只有oldVnode有子節(jié)點(diǎn)，那就把這些節(jié)點(diǎn)都刪除

• 如果只有vnode有子節(jié)點(diǎn)，那就創(chuàng)建這些子節(jié)點(diǎn)

• 如果oldVnode和vnode都沒有子節(jié)點(diǎn)，但是oldVnode是文本節(jié)點(diǎn)或注釋節(jié)點(diǎn)，就把vnode.elm的文本設(shè)置為空字符串

4.如果vnode是文本節(jié)點(diǎn)或注釋節(jié)點(diǎn)，但是vnode.text != oldVnode.text時，只需要更新vnode.elm的文本內(nèi)容就可以

代碼如下：

 function patchVnode (oldVnode, vnode, insertedVnodeQueue, removeOnly) {
 // 如果新舊節(jié)點(diǎn)一致，什么都不做
 if (oldVnode === vnode) {
  return
 }
 // 讓vnode.el引用到現(xiàn)在的真實(shí)dom，當(dāng)el修改時，vnode.el會同步變化
 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.
 // 如果新舊都是靜態(tài)節(jié)點(diǎn)，并且具有相同的key
 // 當(dāng)vnode是克隆節(jié)點(diǎn)或是v-once指令控制的節(jié)點(diǎn)時，只需要把oldVnode.elm和oldVnode.child都復(fù)制到vnode上
 // 也不用再有其他操作
 if (isTrue(vnode.isStatic) &&
  isTrue(oldVnode.isStatic) &&
  vnode.key === oldVnode.key &&
  (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))
 ) {
  vnode.componentInstance = oldVnode.componentInstance
  return
 }
 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
 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)
 }
 // 如果vnode不是文本節(jié)點(diǎn)或者注釋節(jié)點(diǎn)
 if (isUndef(vnode.text)) {
  // 并且都有子節(jié)點(diǎn)
  if (isDef(oldCh) && isDef(ch)) {
  // 并且子節(jié)點(diǎn)不完全一致，則調(diào)用updateChildren
  if (oldCh !== ch) updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly)
  // 如果只有新的vnode有子節(jié)點(diǎn)
  } else if (isDef(ch)) {
  if (isDef(oldVnode.text)) nodeOps.setTextContent(elm, '')
  // elm已經(jīng)引用了老的dom節(jié)點(diǎn)，在老的dom節(jié)點(diǎn)上添加子節(jié)點(diǎn)
  addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue)
  // 如果新vnode沒有子節(jié)點(diǎn)，而vnode有子節(jié)點(diǎn)，直接刪除老的oldCh
  } else if (isDef(oldCh)) {
  removeVnodes(elm, oldCh, 0, oldCh.length - 1)
  // 如果老節(jié)點(diǎn)是文本節(jié)點(diǎn)
  } else if (isDef(oldVnode.text)) {
  nodeOps.setTextContent(elm, '')
  }
  // 如果新vnode和老vnode是文本節(jié)點(diǎn)或注釋節(jié)點(diǎn)
  // 但是vnode.text != oldVnode.text時，只需要更新vnode.elm的文本內(nèi)容就可以
 } 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)
 }
 }

5.updataChildren原理

updateChildren的邏輯是：

分別獲取oldVnode和vnode的firstChild、lastChild，賦值給oldStartVnode、oldEndVnode、newStartVnode、newEndVnode

如果oldStartVnode和newStartVnode是同一節(jié)點(diǎn)，調(diào)用patchVnode進(jìn)行patch，然后將oldStartVnode和newStartVnode都設(shè)置為下一個子節(jié)點(diǎn)，

如果oldEndVnode和newEndVnode是同一節(jié)點(diǎn)，調(diào)用patchVnode進(jìn)行patch，然后將oldEndVnode和newEndVnode都設(shè)置為上一個子節(jié)點(diǎn)，重復(fù)上述流程

如果oldStartVnode和newEndVnode是同一節(jié)點(diǎn)，調(diào)用patchVnode進(jìn)行patch，如果removeOnly是false，那么可以把oldStartVnode.elm移動到oldEndVnode.elm之后，然后把oldStartVnode設(shè)置為下一個節(jié)點(diǎn)，newEndVnode設(shè)置為上一個節(jié)點(diǎn)，重復(fù)上述流程

如果newStartVnode和oldEndVnode是同一節(jié)點(diǎn)，調(diào)用patchVnode進(jìn)行patch，如果removeOnly是false，那么可以把oldEndVnode.elm移動到oldStartVnode.elm之前，然后把newStartVnode設(shè)置為下一個節(jié)點(diǎn)，oldEndVnode設(shè)置為上一個節(jié)點(diǎn)，重復(fù)上述流程

如果以上都不匹配，就嘗試在oldChildren中尋找跟newStartVnode具有相同key的節(jié)點(diǎn)，如果找不到相同key的節(jié)點(diǎn)，說明newStartVnode是一個新節(jié)點(diǎn)，就創(chuàng)建一個，然后把newStartVnode設(shè)置為下一個節(jié)點(diǎn)

如果上一步找到了跟newStartVnode相同key的節(jié)點(diǎn)，那么通過其他屬性的比較來判斷這2個節(jié)點(diǎn)是否是同一個節(jié)點(diǎn)，如果是，就調(diào)用patchVnode進(jìn)行patch，如果removeOnly是false，就把newStartVnode.elm插入到oldStartVnode.elm之前，把newStartVnode設(shè)置為下一個節(jié)點(diǎn)，重復(fù)上述流程

如果在oldChildren中沒有尋找到newStartVnode的同一節(jié)點(diǎn)，那就創(chuàng)建一個新節(jié)點(diǎn)，把newStartVnode設(shè)置為下一個節(jié)點(diǎn)，重復(fù)上述流程

如果oldStartVnode跟oldEndVnode重合了，并且newStartVnode跟newEndVnode也重合了，這個循環(huán)就結(jié)束了

具體代碼如下：

function updateChildren (parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
 let oldStartIdx = 0 // 舊頭索引
 let newStartIdx = 0 // 新頭索引
 let oldEndIdx = oldCh.length - 1 // 舊尾索引
 let newEndIdx = newCh.length - 1 // 新尾索引
 let oldStartVnode = oldCh[0] // oldVnode的第一個child
 let oldEndVnode = oldCh[oldEndIdx] // oldVnode的最后一個child
 let newStartVnode = newCh[0] // newVnode的第一個child
 let newEndVnode = newCh[newEndIdx] // newVnode的最后一個child
 let oldKeyToIdx, idxInOld, vnodeToMove, refElm
 // removeOnly is a special flag used only by <transition-group>
 // to ensure removed elements stay in correct relative positions
 // during leaving transitions
 const canMove = !removeOnly
 // 如果oldStartVnode和oldEndVnode重合，并且新的也都重合了，證明diff完了，循環(huán)結(jié)束
 while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
  // 如果oldVnode的第一個child不存在
  if (isUndef(oldStartVnode)) {
  // oldStart索引右移
  oldStartVnode = oldCh[++oldStartIdx] // Vnode has been moved left
  // 如果oldVnode的最后一個child不存在
  } else if (isUndef(oldEndVnode)) {
  // oldEnd索引左移
  oldEndVnode = oldCh[--oldEndIdx]
  // oldStartVnode和newStartVnode是同一個節(jié)點(diǎn)
  } else if (sameVnode(oldStartVnode, newStartVnode)) {
  // patch oldStartVnode和newStartVnode， 索引左移，繼續(xù)循環(huán)
  patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue)
  oldStartVnode = oldCh[++oldStartIdx]
  newStartVnode = newCh[++newStartIdx]
  // oldEndVnode和newEndVnode是同一個節(jié)點(diǎn)
  } else if (sameVnode(oldEndVnode, newEndVnode)) {
  // patch oldEndVnode和newEndVnode，索引右移，繼續(xù)循環(huán)
  patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue)
  oldEndVnode = oldCh[--oldEndIdx]
  newEndVnode = newCh[--newEndIdx]
  // oldStartVnode和newEndVnode是同一個節(jié)點(diǎn)
  } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right
  // patch oldStartVnode和newEndVnode
  patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue)
  // 如果removeOnly是false，則將oldStartVnode.eml移動到oldEndVnode.elm之后
  canMove && nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm))
  // oldStart索引右移，newEnd索引左移
  oldStartVnode = oldCh[++oldStartIdx]
  newEndVnode = newCh[--newEndIdx]
  // 如果oldEndVnode和newStartVnode是同一個節(jié)點(diǎn)
  } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left
  // patch oldEndVnode和newStartVnode
  patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue)
  // 如果removeOnly是false，則將oldEndVnode.elm移動到oldStartVnode.elm之前
  canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm)
  // oldEnd索引左移，newStart索引右移
  oldEndVnode = oldCh[--oldEndIdx]
  newStartVnode = newCh[++newStartIdx]
  // 如果都不匹配
  } else {
  if (isUndef(oldKeyToIdx)) oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx)
  // 嘗試在oldChildren中尋找和newStartVnode的具有相同的key的Vnode
  idxInOld = isDef(newStartVnode.key)
   ? oldKeyToIdx[newStartVnode.key]
   : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx)
  // 如果未找到，說明newStartVnode是一個新的節(jié)點(diǎn)
  if (isUndef(idxInOld)) { // New element
   // 創(chuàng)建一個新Vnode
   createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm)
  // 如果找到了和newStartVnodej具有相同的key的Vnode，叫vnodeToMove
  } else {
   vnodeToMove = oldCh[idxInOld]
   /* istanbul ignore if */
   if (process.env.NODE_ENV !== 'production' && !vnodeToMove) {
   warn(
    'It seems there are duplicate keys that is causing an update error. ' +
    'Make sure each v-for item has a unique key.'
   )
   }
   // 比較兩個具有相同的key的新節(jié)點(diǎn)是否是同一個節(jié)點(diǎn)
   //不設(shè)key，newCh和oldCh只會進(jìn)行頭尾兩端的相互比較，設(shè)key后，除了頭尾兩端的比較外，還會從用key生成的對象oldKeyToIdx中查找匹配的節(jié)點(diǎn)，所以為節(jié)點(diǎn)設(shè)置key可以更高效的利用dom。
   if (sameVnode(vnodeToMove, newStartVnode)) {
   // patch vnodeToMove和newStartVnode
   patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue)
   // 清除
   oldCh[idxInOld] = undefined
   // 如果removeOnly是false，則將找到的和newStartVnodej具有相同的key的Vnode，叫vnodeToMove.elm
   // 移動到oldStartVnode.elm之前
   canMove && nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm)
   // 如果key相同，但是節(jié)點(diǎn)不相同，則創(chuàng)建一個新的節(jié)點(diǎn)
   } else {
   // same key but different element. treat as new element
   createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm)
   }
  }
  // 右移
  newStartVnode = newCh[++newStartIdx]
  }
 }

6.具體的Diff分析

不設(shè)key，newCh和oldCh只會進(jìn)行頭尾兩端的相互比較，設(shè)key后，除了頭尾兩端的比較外，還會從用key生成的對象oldKeyToIdx中查找匹配的節(jié)點(diǎn)，所以為節(jié)點(diǎn)設(shè)置key可以更高效的利用dom。

diff的遍歷過程中，只要是對dom進(jìn)行的操作都調(diào)用api.insertBefore，api.insertBefore只是原生insertBefore的簡單封裝。

比較分為兩種，一種是有vnode.key的，一種是沒有的。但這兩種比較對真實(shí)dom的操作是一致的。

對于與sameVnode(oldStartVnode, newStartVnode)和sameVnode(oldEndVnode,newEndVnode)為true的情況，不需要對dom進(jìn)行移動。

總結(jié)遍歷過程，有3種dom操作：上述圖中都有

1.當(dāng)oldStartVnode，newEndVnode值得比較，說明oldStartVnode.el跑到oldEndVnode.el的后邊了。

2.當(dāng)oldEndVnode，newStartVnode值得比較，oldEndVnode.el跑到了oldStartVnode.el的前邊，準(zhǔn)確的說應(yīng)該是oldEndVnode.el需要移動到oldStartVnode.el的前邊”。

3.newCh中的節(jié)點(diǎn)oldCh里沒有， 將新節(jié)點(diǎn)插入到oldStartVnode.el的前邊

在結(jié)束時，分為兩種情況：

1.oldStartIdx > oldEndIdx，可以認(rèn)為oldCh先遍歷完。當(dāng)然也有可能newCh此時也正好完成了遍歷，統(tǒng)一都?xì)w為此類。此時newStartIdx和newEndIdx之間的vnode是新增的，調(diào)用addVnodes，把他們?nèi)坎暹M(jìn)before的后邊，before很多時候是為null的。addVnodes調(diào)用的是insertBefore操作dom節(jié)點(diǎn)，我們看看insertBefore的文檔：parentElement.insertBefore(newElement, referenceElement)

如果referenceElement為null則newElement將被插入到子節(jié)點(diǎn)的末尾。如果newElement已經(jīng)在DOM樹中，newElement首先會從DOM樹中移除。所以before為null，newElement將被插入到子節(jié)點(diǎn)的末尾。

2.newStartIdx > newEndIdx，可以認(rèn)為newCh先遍歷完。此時oldStartIdx和oldEndIdx之間的vnode在新的子節(jié)點(diǎn)里已經(jīng)不存在了，調(diào)用removeVnodes將它們從dom里刪除

看完上述內(nèi)容，你們掌握Vue 2.5中怎么實(shí)現(xiàn)一個Diff算法的方法了嗎？如果還想學(xué)到更多技能或想了解更多相關(guān)內(nèi)容，歡迎關(guān)注億速云行業(yè)資訊頻道，感謝各位的閱讀！