轉載自 https://github.com/aooy/blog
前言
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種情況
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)
}
}
複製程式碼具體的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操作：
1.當oldStartVnode，newEndVnode值得比較，說明oldStartVnode.el跑到oldEndVnode.el的後邊了
圖中假設startIdx遍歷到1。