轉載請注明出處
本文轉載至我的blog
目錄
- 前言
- virtual dom
- 分析diff
- 總結
前言
vue2.0加入了virtual dom,有向react靠攏的意思。vue的diff位于patch.js文件中,我的一個小框架aoy也同樣使用此算法,該算法來源于snabbdom,復雜度為O(n)。
了解diff過程可以讓我們更高效的使用框架。
本文力求以圖文并茂的方式來講明這個diff的過程。
virtual dom
如果不了解virtual dom,要理解diff的過程是比較困難的。虛擬dom對應的是真實dom, 使用document.CreateElement
和 document.CreateTextNode
創建的就是真實節點。
我們可以做個試驗。打印出一個空元素的第一層屬性,可以看到標準讓元素實現的東西太多了。如果每次都重新生成新的元素,對性能是巨大的浪費。
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上。
//偽代碼
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一樣。
分析diff
一篇相當經典的文章React’s diff algorithm中的圖,react的diff其實和vue的diff大同小異。所以這張圖能很好的解釋過程。比較只會在同層級進行, 不會跨層級比較。

舉個形象的例子。
<!-- 之前 -->
<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,屬于不同層級的比較。
源碼分析
文中的代碼位于aoy-diff中,已經精簡了很多代碼,留下最核心的部分。
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)
}
}
代碼很密集,為了形象的描述這個過程,可以看看這張圖。
<div align=“center”>

</div>
過程可以概括為:oldCh
和newCh
各有兩個頭尾的變量StartIdx
和EndIdx
,它們的2個變量相互比較,一共有4種比較方式。如果4種比較都沒匹配,如果設置了key,就會用key進行比較,在比較的過程中,變量會往中間靠,一旦StartIdx>EndIdx
表明oldCh
和newCh
至少有一個已經遍歷完了,就會結束比較。
具體的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。

- 當
oldEndVnode
,newStartVnode
值得比較,說明oldEndVnode.el
跑到了newStartVnode.el
的前邊。

- newCh中的節點oldCh里沒有, 將新節點插入到
oldStartVnode.el
的前邊。

在結束時,分為兩種情況:
-
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將被插入到子節點的末尾。

-
newStartIdx > newEndIdx
,可以認為newCh
先遍歷完。此時oldStartIdx
和oldEndIdx
之間的vnode在新的子節點里已經不存在了,調用removeVnodes
將它們從dom里刪除。

下面舉個例子,畫出diff完整的過程,每一步dom的變化都用不同顏色的線標出。
- a,b,c,d,e假設是4個不同的元素,我們沒有設置key時,b沒有復用,而是直接創建新的,刪除舊的。

- 當我們給4個元素加上唯一key時,b得到了的復用。

這個例子如果我們使用手工優化,只需要3步就可以達到。
總結
- 盡量不要跨層級的修改dom
- 設置key可以最大化的利用節點
- 不要盲目相信diff的效率,在必要時可以手工優化