如何使用vue內diff演算法

這次帶給大家怎麼使用vue內diff演算法，使用vue內diff演算法的注意事項有哪些，以下就是實戰案例，一起來看一下。

1. 當資料改變時，vue是怎麼更新節點的？

要知道渲染真實DOM的開銷是很大的，例如有時候我們修改了某個數據，如果直接渲染到真實dom上會引起整個dom樹的重繪和重排，有沒有可能我們只更新我們修改的那一小塊dom而不要更新整個dom呢？ diff演算法能夠幫助我們。

我們先根據真實DOM產生一顆virtual DOM ，當virtual DOM 某個節點的資料改變後會產生一個新的Vnode ，然後Vnode 和oldVnode 作對比，發現有不一樣的地方就直接修改在真實的DOM上，然後使oldVnode 的值為Vnode 。

diff的過程就是呼叫名為 patch 的函數，比較新舊節點，一邊比較一邊給 真實的DOM 打補丁。

2. virtual DOM和真實DOM的差別？

virtual DOM是將真實的DOM的資料抽取出來，以物件的形式模擬樹狀結構。例如dom是這樣的：

<p>
 <p>123</p>
</p>

對應的virtual DOM（偽代碼）：

var Vnode = {
 tag: 'p',
 children: [
  { tag: 'p', text: '123' }
 ]
};

（溫馨提示： VNode 和oldVNode 都是對象，一定要記住）

3. diff的比較方式？

在採取diff演算法比較新舊節點的時候，比較只會在同層級進行, 不會跨層級比較。

<p>
 <p>123</p>
</p>

 456

上面的程式碼會分別比較同一層的兩個p以及第二層的p和span，但不會拿p和span做比較。在別處看到的一張很形象的圖：

diff流程圖

當資料改變時，set方法會讓呼叫Dep.notify 通知所有訂閱者Watcher，訂閱者就會呼叫patch 給真實的DOM打補丁，更新對應的視圖。

特定分析

#patch

來看看patch 是怎麼打補丁的（程式碼只保留核心部分）

function patch (oldVnode, vnode) {
 // some code
 if (sameVnode(oldVnode, vnode)) {
  patchVnode(oldVnode, vnode)
 } else {
  const oEl = oldVnode.el // 当前oldVnode对应的真实元素节点
  let parentEle = api.parentNode(oEl) // 父元素
  createEle(vnode) // 根据Vnode生成新元素
  if (parentEle !== null) {
   api.insertBefore(parentEle, vnode.el, api.nextSibling(oEl)) // 将新元素添加进父元素
   api.removeChild(parentEle, oldVnode.el) // 移除以前的旧元素节点
   oldVnode = null
  }
 }
 // some code 
 return vnode
}

patch函數接收兩個參數oldVnode 和Vnode 分別代表新的節點和之前的舊節點

判斷兩節點是否值得比較，值得比較則執行patchVnode

function sameVnode (a, b) {
 return (
 a.key === b.key && // key值
 a.tag === b.tag && // 标签名
 a.isComment === b.isComment && // 是否为注释节点
 // 是否都定义了data，data包含一些具体信息，例如onclick , style
 isDef(a.data) === isDef(b.data) && 
 sameInputType(a, b) // 当标签是<input>的时候，type必须相同
 )
}

不值得比較則用Vnode 取代oldVnode

如果兩個節點都是一樣的，那麼就深入檢查他們的子節點。如果兩個節點不一樣那就說明 Vnode 完全被改變了，就可以直接取代 oldVnode 。

雖然這兩個節點不一樣但是他們的子節點一樣怎麼辦？別忘了，diff可是逐層比較的，如果第一層不一樣那麼就不會繼續深入比較第二層了。 （我在想這算是缺點嗎？相同子節點不能重複利用了...）

patchVnode

當我們確定兩個節點值得比較之後我們會對兩個節點指定patchVnode 方法。那麼這個方法做了什麼呢？

patchVnode (oldVnode, vnode) {
 const el = vnode.el = oldVnode.el
 let i, oldCh = oldVnode.children, ch = vnode.children
 if (oldVnode === vnode) return
 if (oldVnode.text !== null && vnode.text !== null && oldVnode.text !== vnode.text) {
  api.setTextContent(el, vnode.text)
 }else {
  updateEle(el, vnode, oldVnode)
  if (oldCh && ch && oldCh !== ch) {
   updateChildren(el, oldCh, ch)
  }else if (ch){
   createEle(vnode) //create el's children dom
  }else if (oldCh){
   api.removeChildren(el)
  }
 }
}

這個函數做了以下事情：

1. 找到對應的真實dom，稱為el

2. 判斷Vnode 和oldVnode 是否指向同一個對象，

3. 如果是，那麼直接return 如果他們都有文字節點且不相等，那麼將el 的文字節點設定為Vnode 的文字節點。

4. 如果 oldVnode 有子節點而 Vnode 沒有，則刪除 el 的子節點

5. 如果 oldVnode 没有子节点而 Vnode 有，则将 Vnode 的子节点真实化之后添加到 el 如果两者都有子节点，则执行 updateChildren 函数比较子节点，这一步很重要

其他几个点都很好理解，我们详细来讲一下updateChildren

updateChildren

代码量很大，不方便一行一行的讲解，所以下面结合一些示例图来描述一下。

updateChildren (parentElm, oldCh, newCh) {
 let oldStartIdx = 0, 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
 let idxInOld
 let elmToMove
 let before
 while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
  if (oldStartVnode == null) { // 对于vnode.key的比较，会把oldVnode = null
   oldStartVnode = oldCh[++oldStartIdx] 
  }else if (oldEndVnode == null) {
   oldEndVnode = oldCh[--oldEndIdx]
  }else if (newStartVnode == null) {
   newStartVnode = newCh[++newStartIdx]
  }else if (newEndVnode == null) {
   newEndVnode = newCh[--newEndIdx]
  }else if (sameVnode(oldStartVnode, newStartVnode)) {
   patchVnode(oldStartVnode, newStartVnode)
   oldStartVnode = oldCh[++oldStartIdx]
   newStartVnode = newCh[++newStartIdx]
  }else if (sameVnode(oldEndVnode, newEndVnode)) {
   patchVnode(oldEndVnode, newEndVnode)
   oldEndVnode = oldCh[--oldEndIdx]
   newEndVnode = newCh[--newEndIdx]
  }else if (sameVnode(oldStartVnode, newEndVnode)) {
   patchVnode(oldStartVnode, newEndVnode)
   api.insertBefore(parentElm, oldStartVnode.el, api.nextSibling(oldEndVnode.el))
   oldStartVnode = oldCh[++oldStartIdx]
   newEndVnode = newCh[--newEndIdx]
  }else if (sameVnode(oldEndVnode, newStartVnode)) {
   patchVnode(oldEndVnode, newStartVnode)
   api.insertBefore(parentElm, oldEndVnode.el, oldStartVnode.el)
   oldEndVnode = oldCh[--oldEndIdx]
   newStartVnode = newCh[++newStartIdx]
  }else {
   // 使用key时的比较
   if (oldKeyToIdx === undefined) {
    oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx) // 有key生成index表
   }
   idxInOld = oldKeyToIdx[newStartVnode.key]
   if (!idxInOld) {
    api.insertBefore(parentElm, createEle(newStartVnode).el, oldStartVnode.el)
    newStartVnode = newCh[++newStartIdx]
   }
   else {
    elmToMove = oldCh[idxInOld]
    if (elmToMove.sel !== newStartVnode.sel) {
     api.insertBefore(parentElm, createEle(newStartVnode).el, oldStartVnode.el)
    }else {
     patchVnode(elmToMove, newStartVnode)
     oldCh[idxInOld] = null
     api.insertBefore(parentElm, elmToMove.el, oldStartVnode.el)
    }
    newStartVnode = newCh[++newStartIdx]
   }
  }
 }
 if (oldStartIdx > oldEndIdx) {
  before = newCh[newEndIdx + 1] == null ? null : newCh[newEndIdx + 1].el
  addVnodes(parentElm, before, newCh, newStartIdx, newEndIdx)
 }else if (newStartIdx > newEndIdx) {
  removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx)
 }
}

先说一下这个函数做了什么

1. 将 Vnode 的子节点 Vch 和 oldVnode 的子节点 oldCh 提取出来

2. oldCh 和 vCh 各有两个头尾的变量 StartIdx 和 EndIdx ，它们的2个变量相互比较，一共有4种比较方式。如果4种比较都没匹配，如果设置了 key ，就会用 key 进行比较，在比较的过程中，变量会往中间靠，一旦 StartIdx>EndIdx 表明 oldCh 和 vCh 至少有一个已经遍历完了，就会结束比较。

图解updateChildren

终于来到了这一部分，上面的总结相信很多人也看得一脸懵逼，下面我们好好说道说道。（这都是我自己画的，求推荐好用的画图工具...）

粉红色的部分为oldCh和vCh

我们将它们取出来并分别用s和e指针指向它们的头child和尾child

现在分别对 oldS、oldE、S、E 两两做 sameVnode 比较，有四种比较方式，当其中两个能匹配上那么真实dom中的相应节点会移到Vnode相应的位置，这句话有点绕，打个比方

1. 如果是oldS和E匹配上了，那么真实dom中的第一个节点会移到最后

2. 如果是oldE和S匹配上了，那么真实dom中的最后一个节点会移到最前，匹配上的两个指针向中间移动

3. 如果四种匹配没有一对是成功的，那么遍历 oldChild ， S 挨个和他们匹配，匹配成功就在真实dom中将成功的节点移到最前面，如果依旧没有成功的，那么将 S对应的节点 插入到dom中对应的 oldS 位置， oldS 和 S 指针向中间移动。

再配个图

第一步

oldS = a, oldE = d；
S = a, E = b;

oldS 和 S 匹配，则将dom中的a节点放到第一个，已经是第一个了就不管了，此时dom的位置为：a b d

第二步

oldS = b, oldE = d；
S = c, E = b;

oldS 和 E 匹配，就将原本的b节点移动到最后，因为 E 是最后一个节点，他们位置要一致，这就是上面说的： 当其中两个能匹配上那么真实dom中的相应节点会移到Vnode相应的位置 ，此时dom的位置为：a d b

第三步

oldS = d, oldE = d；
S = c, E = d;

oldE 和 E 匹配，位置不变此时dom的位置为：a d b

第四步

oldS++;
oldE--;
oldS > oldE;

遍历结束，说明 oldCh 先遍历完。就将剩余的 vCh 节点根据自己的的index插入到真实dom中去，此时dom位置为：a c d b

一次模拟完成。

这个匹配过程的结束有两个条件：

oldS > oldE 表示 oldCh 先遍历完，那么就将多余的 vCh 根据index添加到dom中去（如上图） S > E 表示vCh先遍历完，那么就在真实dom中将区间为 [oldS, oldE] 的多余节点删掉

下面再举一个例子，可以像上面那样自己试着模拟一下

当这些节点 sameVnode 成功后就会紧接着执行 patchVnode 了，可以看一下上面的代码

if (sameVnode(oldStartVnode, newStartVnode)) {
 patchVnode(oldStartVnode, newStartVnode)
}

就这样层层递归下去，直到将oldVnode和Vnode中的所有子节点比对完。也将dom的所有补丁都打好啦。那么现在再回过去看updateChildren的代码会不会容易很多呢？

总结

以上为diff算法的全部过程，放上一张文章开始就发过的总结图，可以试试看着这张图回忆一下diff的过程。

相信看了本文案例你已经掌握了方法，更多精彩请关注php中文网其它相关文章！

推荐阅读：

如何使用Vue二次封装axios插件

怎样使用JS实现文件拖拽上传

以上是如何使用vue內diff演算法的詳細內容。更多資訊請關注PHP中文網其他相關文章！