浅析vue2.0的diff算法

Myth丶恋晨 2022-03-07 17:14 163阅读 0赞

## 一、前言 ##

如果不了解virtual dom，要理解diff的过程是比较困难的。

虚拟dom对应的是真实dom， 使用document.CreateElement 和 document.CreateTextNode创建的就是真实节点。

vue2.0才开始使用了virtual dom，有向react靠拢的意思。

文章首发地址：[https://www.mwcxs.top/page/56...][https_www.mwcxs.top_page_56...]

## 二、虚拟dom ##

首先，我们先看一下真实的dom，打印出一个空元素的第一层属性，可以看到标准让元素实现的东西太多了。

如果每次都重新生成新的元素，对性能是巨大的浪费。

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

![image][]

到底什么是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是“解决过多的操作dom影响性能”的一种解决方案。

virtual dom很多时候都不是最优的操作，但它具有普适性，在效率、可维护性之间达平衡。

virutal dom的意义：

1、提供一种简单对象去代替复杂的dom对象，从而优化dom操作

2、提供一个中间层，js去写ui，ios安卓之类的负责渲染，就像reactNative一样。

## 三、diff算法 ##

vue的diff位于patch.js文件中，该算法来源于snabbdom，复杂度为O(n)。了解diff过程可以让我们更高效的使用框架。

一篇相当经典的文章React’s diff algorithm中的图，react的diff其实和vue的diff大同小异。所以这张图能很好的解释过程。

特点：1、比较只会在同层级进行, 不会跨层级比较。

![image][image 1]

举个形象的例子

<div>           
      <p>            
        <b> aoy </b>      
        <span>diff</Span>
      </P> 
    </div>
    
    
    <div>            
      <p>             
          <b> aoy </b>        
      </p>
      <span>diff</Span>
    </div>

我们可能期望将<span>直接移动到<p>的后边，这是最优的操作。

但是实际的diff操作是：1、移除<p>里的<span>；2、在创建一个新的<span>插到<p>的后边。  
因为新加的<span>在层级2，旧的在层级3，属于不同层级的比较。

## 四、源码分析 ##

vue的diff位于patch.js文件中，diff的过程就是调用patch函数，就像打补丁一样修改真实dom。

### 4.1patch方法 ###

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过程。

### 4.2patchNode方法 ###

两个节点值得比较时，会调用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)，新节点没有子节点，老节点有子节点，直接删除老节点。

### 4.3updateChildren方法 ###

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

直接看源码可能比较难以滤清其中的关系，我们通过图来看一下

![image][image 2]

首先，在新老两个VNode节点的左右头尾两侧都有一个变量标记，在遍历过程中这几个变量都会向中间靠拢。

当oldStartIdx <= oldEndIdx或者newStartIdx <= newEndIdx时结束循环。

索引与VNode节点的对应关系：

oldStartIdx => oldStartVnode

oldEndIdx => oldEndVnode

newStartIdx => newStartVnode

newEndIdx => newEndVnode

在遍历中，如果存在key，并且满足sameVnode，会将该DOM节点进行复用，否则则会创建一个新的DOM节点。

首先，oldStartVnode、oldEndVnode与newStartVnode、newEndVnode两两比较一共有2\*2=4种比较方法。

当新老VNode节点的start或者end满足sameVnode时，也就是sameVnode(oldStartVnode, newStartVnode)或者sameVnode(oldEndVnode, newEndVnode)，直接将该VNode节点进行patchVnode即可。

![image][image 3]

如果oldStartVnode与newEndVnode满足sameVnode，即sameVnode(oldStartVnode, newEndVnode)。

这时候说明oldStartVnode已经跑到了oldEndVnode后面去了，进行patchVnode的同时还需要将真实DOM节点移动到oldEndVnode的后面。

![image][image 4]

如果oldEndVnode与newStartVnode满足sameVnode，即sameVnode(oldEndVnode, newStartVnode)。

这说明oldEndVnode跑到了oldStartVnode的前面，进行patchVnode的同时真实的DOM节点移动到了oldStartVnode的前面。

![image][image 5]

如果以上情况均不符合，则通过createKeyToOldIdx会得到一个oldKeyToIdx，里面存放了一个key为旧的VNode，value为对应index序列的哈希表。从这个哈希表中可以找到是否有与newStartVnode一致key的旧的VNode节点，如果同时满足sameVnode，patchVnode的同时会将这个真实DOM（elmToMove）移动到oldStartVnode对应的真实DOM的前面。

![image][image 5]

当然也有可能newStartVnode在旧的VNode节点找不到一致的key，或者是即便key相同却不是sameVnode，这个时候会调用createElm创建一个新的DOM节点。

![image][image 6]

到这里循环已经结束了，那么剩下我们还需要处理多余或者不够的真实DOM节点。

[https_www.mwcxs.top_page_56...]: https://www.mwcxs.top/page/560.html
[image]: /images/20220307/0339879327fa4db69672288b73b79256.png
[image 1]: /images/20220307/e340456975374d83ac5d960d36e1ea7b.png
[image 2]: /images/20220307/dc3b36be9beb47259a22b1d046f63d28.png
[image 3]: /images/20220307/eb83a5aad9d646dea93e990ecdd610ad.png
[image 4]: /images/20220307/8708da21e28a4ac4be619281ed7d8070.png
[image 5]: /images/20220307/1aa7452e707f4f46bc7eb1d003bb91ee.png
[image 6]: /images/20220307/7aa4626cd1c74a3dba2b0f2d6795bd21.png