【Vuejs】351- 帶你解析vue2.0的diff算法

時間  2019-11-30
標籤 Vuejs 解析 vue2.0 vue diff 算法 简体版
原文   原文鏈接
640

前言javascript

vue2.0加入了virtual dom，有向react靠攏的意思。vue的diff位於patch.js文件中，該算法來源於snabbdom，複雜度爲O(n)。瞭解diff過程可讓咱們更高效的使用框架。vue

01java

virtual domnode

若是不瞭解virtual dom，要理解diff的過程是比較困難的。虛擬dom對應的是真實dom， 使用document.CreateElement 和 document.CreateTextNode建立的就是真實節點。react

咱們能夠作個試驗。打印出一個空元素的第一層屬性，能夠看到標準讓元素實現的東西太多了。若是每次都從新生成新的元素，對性能是巨大的浪費。ios

var mydiv = document.createElement('div');	
for(var k in mydiv ){	
  console.log(k)	
}var mydiv = document.createElement('div');for(var k in mydiv ){  console.log(k)}

virtual dom就是解決這個問題的一個思路，到底什麼是virtual dom呢？通俗易懂的來講就是用一個簡單的對象去代替複雜的dom對象。舉個簡單的例子，咱們在body裏插入一個class爲a的div。算法

var mydiv = document.createElement('div');	
mydiv.className = 'a';	
document.body.appendChild(mydiv);

對於這個div咱們能夠用一個簡單的對象mydivVirtual表明它，它存儲了對應dom的一些重要參數，在改變dom以前，會先比較相應虛擬dom的數據，若是須要改變，纔會將改變應用到真實dom上。api

//僞代碼	
var mydivVirtual = { 	
  tagName: 'DIV',	
  className: 'a'	
};	
var newmydivVirtual = {	
   tagName: 'DIV',	
   className: 'b'	
}	
if(mydivVirtual.tagName !== newmydivVirtual.tagName || mydivVirtual.className  !== newmydivVirtual.className){	
   change(mydiv)	
}	

	
// 會執行相應的修改 mydiv.className = 'b';	
//最後  <div class='b'></div>

讀到這裏就會產生一個疑問，爲何不直接修改dom而須要加一層virtual dom呢？

不少時候手工優化dom確實會比virtual dom效率高，對於比較簡單的dom結構用手工優化沒有問題，但當頁面結構很龐大，結構很複雜時，手工優化會花去大量時間，並且可維護性也不高，不能保證每一個人都有手工優化的能力。至此，virtual dom的解決方案應運而生，virtual dom不少時候都不是最優的操做，但它具備普適性，在效率、可維護性之間達到平衡。數組

virtual dom 另外一個重大意義就是提供一箇中間層，js去寫ui，ios安卓之類的負責渲染，就像reactNative同樣。app

02

分析diff算法

一篇至關經典的文章React’s diff algorithm中的圖，react的diff其實和vue的diff大同小異。因此這張圖能很好的解釋過程。比較只會在同層級進行, 不會跨層級比較。

640?wx_fmt=png

舉個形象的例子。

<!-- 以前 -->	
<div>           <!-- 層級1 -->	
  <p>            <!-- 層級2 -->	
    <b> aoy </b>   <!-- 層級3 -->   	
    <span>diff</Span>	
  </P> 	
</div>	

	
<!-- 以後 -->	
<div>            <!-- 層級1 -->	
  <p>             <!-- 層級2 -->	
      <b> aoy </b>        <!-- 層級3 -->	
  </p>	
  <span>diff</Span>	
</div>

咱們可能指望將<span>直接移動到<p>的後邊，這是最優的操做。可是實際的diff操做是移除<p>標籤裏的<span>在建立一個新的<span>插到<p>的後邊。由於新加的<span>在層級2，舊的在層級3，屬於不一樣層級的比較。

03

源碼分析

diff的過程就是調用patch函數，就像打補丁同樣修改真實dom。

function patch (oldVnode, vnode) {	
  if (sameVnode(oldVnode, vnode)) {	
    patchVnode(oldVnode, vnode)	
  } else {	
    const oEl = oldVnode.el	
    let parentEle = api.parentNode(oEl)	
    createEle(vnode)	
    if (parentEle !== null) {	
      api.insertBefore(parentEle, vnode.el, api.nextSibling(oEl))	
      api.removeChild(parentEle, oldVnode.el)	
      oldVnode = null	
    }	
  }	
  return vnode	
}

patch函數有兩個參數，vnode和oldVnode，也就是新舊兩個虛擬節點。在這以前，咱們先了解完整的vnode都有什麼屬性，舉個一個簡單的例子:

// body下的 <div id="v" class="classA"><div> 對應的 oldVnode 就是	

	
{	
  el:  div  //對真實的節點的引用，本例中就是document.querySelector('#id.classA')	
  tagName: 'DIV',   //節點的標籤	
  sel: 'div#v.classA'  //節點的選擇器	
  data: null,       // 一個存儲節點屬性的對象，對應節點的el[prop]屬性，例如onclick , style	
  children: [], //存儲子節點的數組，每一個子節點也是vnode結構	
  text: null,    //若是是文本節點，對應文本節點的textContent，不然爲null	
}

須要注意的是，el屬性引用的是此 virtual dom對應的真實dom，patch的vnode參數的el最初是null，由於patch以前它尚未對應的真實dom。

來到patch的第一部分，

if (sameVnode(oldVnode, vnode)) {	
  patchVnode(oldVnode, vnode)	
}

sameVnode函數就是看這兩個節點是否值得比較，代碼至關簡單：

function sameVnode(oldVnode, vnode){	
  return vnode.key === oldVnode.key && vnode.sel === oldVnode.sel	
}

兩個vnode的key和sel相同纔去比較它們，好比p和span，div.classA和div.classB都被認爲是不一樣結構而不去比較它們。

若是值得比較會執行patchVnode(oldVnode, vnode)，稍後會詳細講patchVnode函數。

當節點不值得比較，進入else中

else {	
    const oEl = oldVnode.el	
    let parentEle = api.parentNode(oEl)	
    createEle(vnode)	
    if (parentEle !== null) {	
      api.insertBefore(parentEle, vnode.el, api.nextSibling(oEl))	
      api.removeChild(parentEle, oldVnode.el)	
      oldVnode = null	
    }	
  }

過程以下：

  • 取得oldvnode.el的父節點，parentEle是真實dom

  • createEle(vnode)會爲vnode建立它的真實dom，令vnode.el =真實dom

  • parentEle將新的dom插入，移除舊的dom當不值得比較時，新節點直接把老節點整個替換了

最後 

return vnode

patch最後會返回vnode，vnode和進入patch以前的不一樣在哪？沒錯，就是vnode.el，惟一的改變就是以前vnode.el = null, 而如今它引用的是對應的真實dom。

var oldVnode = patch (oldVnode, vnode)

至此完成一個patch過程。

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

const el = vnode.el = oldVnode.el 這是很重要的一步，讓vnode.el引用到如今的真實dom，當el修改時，vnode.el會同步變化。

節點的比較有5種狀況

  1. if (oldVnode === vnode)，他們的引用一致，能夠認爲沒有變化。

  2. if(oldVnode.text !== null && vnode.text !== null && oldVnode.text !== vnode.text)，文本節點的比較，須要修改，則會調用Node.textContent = vnode.text。

  3. if( oldCh && ch && oldCh !== ch ), 兩個節點都有子節點，並且它們不同，這樣咱們會調用updateChildren函數比較子節點，這是diff的核心，後邊會講到。

  4. else if (ch)，只有新的節點有子節點，調用createEle(vnode)，vnode.el已經引用了老的dom節點，createEle函數會在老dom節點上添加子節點。

  5. else if (oldCh)，新節點沒有子節點，老節點有子節點，直接刪除老節點。

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

代碼很密集，爲了形象的描述這個過程，能夠看看這張圖。

640?wx_fmt=png

過程能夠歸納爲：oldCh和newCh各有兩個頭尾的變量StartIdx和EndIdx，它們的2個變量相互比較，一共有4種比較方式。若是4種比較都沒匹配，若是設置了key，就會用key進行比較，在比較的過程當中，變量會往中間靠，一旦StartIdx>EndIdx代表oldCh和newCh至少有一個已經遍歷完了，就會結束比較。

04

具體的diff分析

設置key和不設置key的區別：        不設key，newCh和oldCh只會進行頭尾兩端的相互比較，設key後，除了頭尾兩端的比較外，還會從用key生成的對象oldKeyToIdx中查找匹配的節點，因此爲節點設置key能夠更高效的利用dom。

diff的遍歷過程當中，只要是對dom進行的操做都調用api.insertBefore，api.insertBefore只是原生insertBefore的簡單封裝。比較分爲兩種，一種是有vnode.key的，一種是沒有的。但這兩種比較對真實dom的操做是一致的。

對於與sameVnode(oldStartVnode, newStartVnode)和sameVnode(oldEndVnode,newEndVnode)爲true的狀況，不須要對dom進行移動。

總結遍歷過程，有3種dom操做：

當oldStartVnode，newEndVnode值得比較，說明oldStartVnode.el跑到oldEndVnode.el的後邊了。

圖中假設startIdx遍歷到1。

640?wx_fmt=png

當oldEndVnode，newStartVnode值得比較，說明 oldEndVnode.el跑到了newStartVnode.el的前邊。（這裏筆誤，應該是「oldEndVnode.el跑到了oldStartVnode.el的前邊」，準確的說應該是oldEndVnode.el須要移動到oldStartVnode.el的前邊」）

640?wx_fmt=png

newCh中的節點oldCh裏沒有， 將新節點插入到oldStartVnode.el的前邊。

640?wx_fmt=png

在結束時，分爲兩種狀況：

一、oldStartIdx > oldEndIdx，能夠認爲oldCh先遍歷完。固然也有可能newCh此時也正好完成了遍歷，統一都歸爲此類。此時newStartIdx和newEndIdx之間的vnode是新增的，調用addVnodes，把他們所有插進before的後邊，before不少時候是爲null的。addVnodes調用的是insertBefore操做dom節點，咱們看看insertBefore的文檔：parentElement.insertBefore(newElement, referenceElement)二、若是referenceElement爲null則newElement將被插入到子節點的末尾。若是newElement已經在DOM樹中，newElement首先會從DOM樹中移除。因此before爲null，newElement將被插入到子節點的末尾。

640?wx_fmt=png

newStartIdx > newEndIdx，能夠認爲newCh先遍歷完。此時oldStartIdx和oldEndIdx之間的vnode在新的子節點裏已經不存在了，調用removeVnodes將它們從dom裏刪除。

640?wx_fmt=png

下面舉個例子，畫出diff完整的過程，每一步dom的變化都用不一樣顏色的線標出。

1.a,b,c,d,e假設是4個不一樣的元素，咱們沒有設置key時，b沒有複用，而是直接建立新的，刪除舊的。

640?wx_fmt=png

當咱們給4個元素加上惟一key時，b獲得了的複用。

640?wx_fmt=png

這個例子若是咱們使用手工優化，只須要3步就能夠達到。

05

總結

  • 儘可能不要跨層級的修改dom

  • 設置key能夠最大化的利用節點

  • diff的效率並非每種狀況下都是最優的

感謝楊敬亭大佬的分享纔有了這篇文章，建議反覆閱讀5遍以上，加深理解虛擬DOM原理。❤️

END

▼
原創系列推薦
▼



4. 
5. 
6. 
7. 

640?wx_fmt=png
點這，與你們一塊兒分享本文吧~
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程