VUE、React中虛擬DOM（virtual DOM）技術 VNode及diff算法介紹

時間 2019-11-15

標籤 vue react 虛擬 dom virtual 技術 vnode diff 算法介紹欄目 React 简体版

原文原文鏈接

前言

前端主流框架 vue 和 react 中都使用了虛擬DOM（virtual DOM）技術，由於渲染真實DOM的開銷是很大的，性能代價昂貴，好比有時候咱們修改了某個數據，若是直接渲染到真實dom上會引發整個dom樹的重繪和重排，而咱們只須要更新修改過的那一小塊dom而不要更新整個dom，這時使用diff算法可以幫助咱們。那什麼是虛擬DOM和diff算法呢？javascript

虛擬DOM和VNode介紹

所謂虛擬DOM，是一個用於表示真實 DOM 結構和屬性的 JavaScript 對象，這個對象用於對比虛擬 DOM 和當前真實 DOM 的差別化，而後進行局部渲染從而實現性能上的優化。在Vue.js 中虛擬 DOM 的 JavaScript 對象就是 VNode。前端

VNode 表示虛擬節點 Virtual DOM，爲何叫虛擬節點呢，由於不是真的 DOM 節點。他只是用 javascript 對象來描述真實 DOM，這麼描述，把DOM標籤，屬性，內容都變成對象的屬性。就像用 JavaScript 對象描述一我的同樣： {sex:'女', name:'voanit', salary:5000,children:null} 過程就是，把你的 template 模板描述成 VNode，而後一系列操做以後經過 VNode 造成真實DOM進行掛載。vue

什麼用？

1兼容性強，不受執行環境的影響。VNode 由於是 JS 對象，無論 Node 仍是瀏覽器，均可以統一操做，從而得到了服務端渲染、原生渲染、手寫渲染函數等能力java

2減小操做 DOM。任何頁面的變化，都只使用 VNode 進行操做對比，只須要在最後一步掛載更新DOM，不須要頻繁操做DOM，從而提升頁面性能node

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

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

virtual dom就是解決這個問題的一個思路，用一個簡單的對象去代替複雜的dom對象。舉個簡單的例子，咱們在body裏插入一個class爲a的div。linux

var mydiv = document.createElement('div');
mydiv.className = 'a';
document.body.appendChild(mydiv);
複製代碼

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

//僞代碼
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同樣。api

分析diff

diff算法源自於：linux的基本命令，對比文本。vue和react的虛擬DOM的diff算法大體相同，其核心是基於兩個簡單的假設：1. 兩個相同的組件產生相似的DOM結構，不一樣的組件產生不一樣的DOM結構。2. 同一層級的一組節點，他們能夠經過惟一的id進行區分。

例如

<ul id='list'>
	<li class='item'>Item 1</li>
	<li class='item'>Item 1</li>
</ul>
複製代碼

生成的vdom爲：

{
	tag: 'url',
	attrs: {id: 'list'},
	children: [
		{
			tag: 'li',
			attrs:{className:'item'},
			children:['Item 1']
		},
		{
			tag: 'li',
			attrs:{className:'item'},
			children:['Item 2']
		},
	]
}
複製代碼

舉個形象的例子。

<!-- 以前 -->
<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>
複製代碼

咱們可能指望將直接移動到

的後邊，這是最優的操做。可是實際的diff操做是移除

裏的在建立一個新的插到

的後邊。由於新加的在層級2，舊的在層級3，屬於不一樣層級的比較。

源碼分析

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種狀況

if (oldVnode === vnode)，他們的引用一致，能夠認爲沒有變化。
if(oldVnode.text !== null && vnode.text !== null && oldVnode.text !== vnode.text)，文本節點的比較，須要修改，則會調用Node.textContent = vnode.text。
if( oldCh && ch && oldCh !== ch ), 兩個節點都有子節點，並且它們不同，這樣咱們會調用updateChildren函數比較子節點，這是diff的核心，後邊會講到。
else if (ch)，只有新的節點有子節點，調用createEle(vnode)，vnode.el已經引用了老的dom節點，createEle函數會在老dom節點上添加子節點。
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)
        }
}
複製代碼

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

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

以上爲本期介紹的VNode和diff算法，您能夠關注前端之階公衆號，關注更多前端知識，獲取前端大羣，裏面不少知名互聯網前端朋友，前端技術更新太快，不能被落伍淘汰，共同窗習，共同進步！