vue.js の差分アルゴリズムについての深い理解

この記事では、vue.js の差分アルゴリズムについて詳しく説明します。一定の参考値があるので、困っている友達が参考になれば幸いです。

まえがき

私の目標は diff の詳細な紹介を書くことなので、この記事は少し長くなります。この記事を読んだ友達が diff を隅々まで理解できるように、画像とコード例も多数使用します。

最初にいくつかのポイントを理解しましょう...

1. データが変更されると、vue はどのようにノードを更新しますか?

実際の DOM をレンダリングするコストは非常に高いことを知っておく必要があります。たとえば、特定のデータを変更することがあります。それを実際の DOM に直接レンダリングすると、DOM 全体に問題が発生します。 dom 全体を更新するのではなく、変更した dom の小さな部分だけを更新することは可能でしょうか? diff アルゴリズムが役に立ちます。

最初に実際の DOM に基づいて仮想 DOM を生成します。仮想 DOM 内のノードのデータが変更されると、新しい Vnode が生成されます。次に、Vnode と古い Vnode を比較し、存在する場合は直接変更します。実際の DOM では、oldVnode Vnode の値を作成します。

diff のプロセスは、patch という名前の関数を呼び出し、古いノードと新しいノードを比較し、比較しながら実際の DOM にパッチを適用することです。

2. 仮想 DOM と実際の DOM の違いは何ですか?

仮想 DOM は、実際の DOM データを抽出し、オブジェクトの形式でツリー構造をシミュレートします。たとえば、dom は次のようになります:

<div>
    <p>123</p>
  </div>

対応する仮想 DOM (疑似コード):

var Vnode = {
    tag: 'div',
    children: [
        { tag: 'p', text: '123' }
    ]
};

(注意: VNode と oldVNode は両方ともオブジェクトです。必ず覚えておいてください)

3. 差分を比較するにはどうすればよいですか?

diff アルゴリズムを使用して古いノードと新しいノードを比較する場合、比較は同じレベルでのみ実行され、レベル間での比較は行われません。

<div>
    <p>123</p>
</div>

<div>
    <span>456</span>
</div>

上記のコードは、同じレイヤーの 2 つの div と 2 番目のレイヤーの p と span を比較しますが、div と spam は比較しません。他の場所で見た非常に鮮明な図:

diff フローチャート

データが変更されると、set メソッド Dep.notify がすべてのサブスクライバ ウォッチャーに通知するために呼び出され、サブスクライバは patch を呼び出して実際の DOM にパッチを適用し、対応するビューを更新します。

#詳細な分析

パッチ

パッチがどのように適用されるかを見てみましょう (コードはコア部分のみを保持します)

function patch (oldVnode, vnode) {
    // some code
    if (sameVnode(oldVnode, vnode)) {
        patchVnode(oldVnode, vnode)
    } else {
        const oEl = oldVnode.el // 当前oldVnode对应的真实元素节点
        let parentEle = api.parentNode(oEl)  // 父元素
        createEle(vnode)  // 根据Vnode生成新元素
        if (parentEle !== null) {
            api.insertBefore(parentEle, vnode.el, api.nextSibling(oEl)) // 将新元素添加进父元素
            api.removeChild(parentEle, oldVnode.el)  // 移除以前的旧元素节点
            oldVnode = null
        }
    }
    // some code 
    return vnode
}

patch 関数は、それぞれ新しいノードと以前の古いノードを表す 2 つのパラメーター oldVnode と Vnode を受け取ります

2 つのノードが比較に値するかどうかを判断します。比較する価値がある場合は、patchVnode

function sameVnode (a, b) {
  return (
    a.key === b.key &&  // key值
    a.tag === b.tag &&  // 标签名
    a.isComment === b.isComment &&  // 是否为注释节点
    // 是否都定义了data，data包含一些具体信息，例如onclick , style
    isDef(a.data) === isDef(b.data) &&  
    sameInputType(a, b) // 当标签是<input>的时候，type必须相同
  )
}

を実行します。比較する価値がない場合は、oldVnode を Vnode

に置き換えます。両方のノードが同じである場合は、子ノードを詳しく確認します。 2 つのノードが異なる場合は、Vnode が完全に変更されたことを意味し、oldVnode を直接置き換えることができます。

これら 2 つのノードは異なりますが、子ノードが同じ場合はどうすればよいでしょうか? diff はレイヤーごとに比較されることを忘れないでください。最初のレイヤーが異なる場合、2 番目のレイヤーは詳細には比較されません。 (デメリットかな？同じ子ノードは再利用できないので…)

patchVnode

2つのノードが比較に値すると判断した場合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)
        }
    }
}

この関数は次のことを行います:

• el と呼ばれる対応する実際の dom を見つけます

• Vnode とoldVnode が同じオブジェクトを指している場合は、直接戻ります。

• 両方のテキスト ノードがあり、等しくない場合は、el のテキスト ノードを Vnode のテキスト ノードに設定します。

• oldVnode には子ノードがあるが、Vnode には子ノードがない場合は、el の子ノードを削除します。

• oldVnode には子ノードがなく、Vnode には子ノードがある場合、 Vnode の子ノードが認識された後、el

• 両方に子ノードがある場合は、updateChildren 関数を実行して子ノードを比較します。このステップは非常に重要です

その他の点は分かりやすいので、updateChildren について詳しく説明します

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

最初にこの関数が何をするのかについて話しましょう

• Vnode の子ノード Vch と oldVnode の子ノード oldCh を抽出します

• oldCh と vCh には、先頭と末尾に StartIdx と EndIdx という 2 つの変数があり、これら 2 つの変数を比較するため、合計 4 つの比較方法があります。 4 つの比較のどれも一致しない場合、キーが設定されている場合は、そのキーが比較に使用されます。比較プロセス中に、変数は中央に移動します。StartIdx>EndIdx が oldCh と vCh の少なくとも 1 つが指定されたことを示すと、横断したら終わりです。比較してください。

图解updateChildren

终于来到了这一部分，上面的总结相信很多人也看得一脸懵逼，下面我们好好说道说道。（这都是我自己画的，求推荐好用的画图工具...）

粉红色的部分为oldCh和vCh

我们将它们取出来并分别用s和e指针指向它们的头child和尾child

现在分别对oldS、oldE、S、E两两做sameVnode比较，有四种比较方式，当其中两个能匹配上那么真实dom中的相应节点会移到Vnode相应的位置，这句话有点绕，打个比方

• 如果是oldS和E匹配上了，那么真实dom中的第一个节点会移到最后

• 如果是oldE和S匹配上了，那么真实dom中的最后一个节点会移到最前，匹配上的两个指针向中间移动

• 如果四种匹配没有一对是成功的，那么遍历oldChild，S挨个和他们匹配，匹配成功就在真实dom中将成功的节点移到最前面，如果依旧没有成功的，那么将S对应的节点插入到dom中对应的oldS位置，oldS和S指针向中间移动。

再配个图

第一步

oldS = a, oldE = d；
S = a, E = b;

oldS和S匹配，则将dom中的a节点放到第一个，已经是第一个了就不管了，此时dom的位置为：a b d

第二步

oldS = b, oldE = d；
S = c, E = b;

oldS和E匹配，就将原本的b节点移动到最后，因为E是最后一个节点，他们位置要一致，这就是上面说的：当其中两个能匹配上那么真实dom中的相应节点会移到Vnode相应的位置，此时dom的位置为：a d b

第三步

oldS = d, oldE = d；
S = c, E = d;

oldE和E匹配，位置不变此时dom的位置为：a d b

第四步

oldS++;
oldE--;
oldS > oldE;

遍历结束，说明oldCh先遍历完。就将剩余的vCh节点根据自己的的index插入到真实dom中去，此时dom位置为：a c d b

一次模拟完成。

这个匹配过程的结束有两个条件：

• oldS > oldE表示oldCh先遍历完，那么就将多余的vCh根据index添加到dom中去（如上图）

• S > E表示vCh先遍历完，那么就在真实dom中将区间为[oldS, oldE]的多余节点删掉

下面再举一个例子，可以像上面那样自己试着模拟一下

当这些节点sameVnode成功后就会紧接着执行patchVnode了，可以看一下上面的代码

if (sameVnode(oldStartVnode, newStartVnode)) {
    patchVnode(oldStartVnode, newStartVnode)
}

总结

以上为diff算法的全部过程，放上一张文章开始就发过的总结图，可以试试看着这张图回忆一下diff的过程。

相关推荐：

2020年前端vue面试题大汇总（附答案）

vue教程推荐：2020最新的5个vue.js视频教程精选

更多编程相关知识，请访问：编程入门！！

以上がvue.js の差分アルゴリズムについての深い理解の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。