Vue에서 diff 알고리즘을 사용하는 방법

이번에는 vue에서 diff 알고리즘을 사용하는 방법과 vue에서 diff 알고리즘을 사용할 때의 주의 사항에 대해 설명하겠습니다. 다음은 실제 사례입니다.

1. 데이터가 변경되면 Vue는 어떻게 노드를 업데이트하나요?

실제 DOM을 렌더링하는 데 드는 비용이 매우 높다는 것을 알아야 합니다. 예를 들어 특정 데이터를 실제 DOM에 직접 렌더링하면 전체 DOM 트리가 다시 그려지고 재배열되는 경우가 있습니다. 전체 DOM을 업데이트하는 대신 수정한 DOM의 작은 부분만 업데이트하는 것이 가능합니까? diff 알고리즘이 우리에게 도움이 될 수 있습니다.

먼저 실제 DOM을 기반으로 가상 DOM을 생성합니다. 가상 DOM에 있는 노드의 데이터가 변경되면 새로운 Vnode가 생성됩니다. 생성된 다음 Vnode와 oldVnode를 비교합니다. 차이점을 발견하면 실제 DOM에서 직접 수정한 다음 oldVnode의 값을 만듭니다. 코드> <code>Vnode. virtual DOM ，当 virtual DOM 某个节点的数据改变后会生成一个新的 Vnode ，然后 Vnode 和 oldVnode 作对比，发现有不一样的地方就直接修改在真实的DOM上，然后使 oldVnode 的值为 Vnode 。

diff的过程就是调用名为 patch 的函数，比较新旧节点，一边比较一边给 真实的DOM 打补丁。

2. virtual DOM和真实DOM的区别？

virtual DOM是将真实的DOM的数据抽取出来，以对象的形式模拟树形结构。比如dom是这样的：

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

对应的virtual DOM（伪代码）：

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

（温馨提示： VNode 和 oldVNode 都是对象，一定要记住）

3. diff的比较方式？

在采取diff算法比较新旧节点的时候，比较只会在同层级进行, 不会跨层级比较。

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

 456

上面的代码会分别比较同一层的两个p以及第二层的p和span，但是不会拿p和span作比较。在别处看到的一张很形象的图：

diff流程图

当数据发生改变时，set方法会让调用 Dep.notify 通知所有订阅者Watcher，订阅者就会调用 patch 给真实的DOM打补丁，更新相应的视图。

具体分析

patch

来看看 patch 是怎么打补丁的（代码只保留核心部分）

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函数接收两个参数 oldVnode 和 Vnode 分别代表新的节点和之前的旧节点

判断两节点是否值得比较，值得比较则执行 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必须相同
 )
}

不值得比较则用 Vnode 替换 oldVnode

如果两个节点都是一样的，那么就深入检查他们的子节点。如果两个节点不一样那就说明 Vnode 完全被改变了，就可以直接替换 oldVnode 。

虽然这两个节点不一样但是他们的子节点一样怎么办？别忘了，diff可是逐层比较的，如果第一层不一样那么就不会继续深入比较第二层了。（我在想这算是一个缺点吗？相同子节点不能重复利用了...）

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

这个函数做了以下事情：

1. 找到对应的真实dom，称为 el

2. 判断 Vnode 和 oldVnode 是否指向同一个对象，

3. 如果是，那么直接 return 如果他们都有文本节点并且不相等，那么将 el 的文本节点设置为 Vnode 的文本节点。

4. 如果 oldVnode 有子节点而 Vnode 没有，则删除 el

   diff 프로세스는 patch라는 함수 🎜를 호출하는 것입니다. 비교적 새롭고 오래된 노드이므로 🎜실제 DOM🎜을 동시에 비교하고 패치하세요. 🎜🎜🎜2. 가상 DOM과 실제 DOM의 차이점은 무엇인가요? 🎜🎜🎜virtual DOM은 실제 DOM 데이터를 추출하고 object🎜 구조 형태로 트리 모양을 시뮬레이션합니다. 예를 들어, dom은 다음과 같습니다: 🎜

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

   🎜해당 가상 DOM(의사 코드): 🎜

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

   🎜 (주의: VNode 및 oldVNode는 둘 다 객체이므로 꼭 기억하세요 )🎜🎜🎜3. 차이점을 비교하는 방법은 무엇인가요? 🎜🎜🎜diff 알고리즘을 사용하여 이전 노드와 새 노드를 비교할 때 비교는 동일한 수준에서만 수행되며 수준 간 비교는 수행되지 않습니다. 🎜

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

   🎜위 코드는 같은 레이어의 두 p와 두 번째 레이어의 p와span을 비교하지만 p와span을 비교하지는 않습니다. 다른 곳에서 본 아주 생생한 사진: 🎜🎜🎜

   🎜diff 순서도🎜🎜🎜데이터가 변경되면 설정 메소드는 Dep.notify를 호출하여 모든 구독자 Watcher, 구독자에게 패치를 알립니다. code>가 호출되어 실제 DOM을 패치하고 해당 view🎜를 업데이트합니다. 🎜🎜🎜

   🎜상세 분석🎜🎜

   🎜patch🎜🎜🎜patch가 어떻게 패치되는지 살펴보겠습니다(코드의 핵심 부분만 유지됨)🎜

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

   🎜 패치 함수는 각각 새 노드와 이전 노드를 나타내는 두 개의 매개변수 oldVnode 및 Vnode를 받습니다. 🎜🎜두 노드가 비교할 가치가 있는지 판단하세요. 비교할 가치가 있으면 patchVnode 🎜

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

   🎜를 실행하세요. 비교할 가치가 없다면 oldVnode를 Vnode🎜🎜로 바꾸세요. 동일한 경우 하위 노드를 자세히 확인하세요. 두 노드가 다르다면 Vnode가 완전히 변경되었다는 의미이며, oldVnode를 직접 교체할 수 있습니다. 🎜🎜두 노드는 다르지만, 자식 노드가 같다면 어떻게 해야 하나요? 잊지 마세요. diff는 레이어별로 비교됩니다. 첫 번째 레이어가 다르면 두 번째 레이어는 깊이 비교되지 않습니다. (이게 단점일까? 동일한 하위 노드는 재사용할 수 없다...) 🎜🎜🎜patchVnode🎜🎜🎜두 노드가 비교할 가치가 있다고 판단되면 두 노드에 대해 patchVnode를 지정합니다. .코드> 메소드. 그렇다면 이 방법은 무엇을 하는가? 🎜<div class="code" style="position:relative; padding:0px; margin:0px;"><div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false">if (sameVnode(oldStartVnode, newStartVnode)) {  patchVnode(oldStartVnode, newStartVnode) }</pre><div class="contentsignin">로그인 후 복사</div></div><div class="contentsignin">로그인 후 복사</div></div>🎜이 함수는 다음을 수행합니다: 🎜<ol class=" list-paddingleft-2"> <li>🎜 <code>el🎜
5. 🎜이라는 해당 실제 DOM을 찾습니다. Vnode와 oldVnode가 동일한 객체를 가리키는지 확인하세요. 🎜
6. 🎜그렇다면 둘 다인 경우 직접 return하세요. 텍스트 노드가 있고 같지 않은 경우 el의 텍스트 노드를 Vnode의 텍스트 노드로 설정합니다. 🎜
7. 🎜oldVnode에 하위 노드가 있지만 Vnode에는 없으면 el의 하위 노드를 삭제하세요🎜

8. 如果 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)
 }
}

先说一下这个函数做了什么

1. 将 Vnode 的子节点 Vch 和 oldVnode 的子节点 oldCh 提取出来

2. oldCh 和 vCh 各有两个头尾的变量 StartIdx 和 EndIdx ，它们的2个变量相互比较，一共有4种比较方式。如果4种比较都没匹配，如果设置了 key ，就会用 key 进行比较，在比较的过程中，变量会往中间靠，一旦 StartIdx>EndIdx 表明 oldCh 和 vCh 至少有一个已经遍历完了，就会结束比较。

图解updateChildren

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

粉红色的部分为oldCh和vCh

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

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

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

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

3. 如果四种匹配没有一对是成功的，那么遍历 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)
}

就这样层层递归下去，直到将oldVnode和Vnode中的所有子节点比对完。也将dom的所有补丁都打好啦。那么现在再回过去看updateChildren的代码会不会容易很多呢？

总结

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

相信看了本文案例你已经掌握了方法，更多精彩请关注php中文网其它相关文章！

推荐阅读：

如何使用Vue二次封装axios插件

怎样使用JS实现文件拖拽上传

위 내용은 Vue에서 diff 알고리즘을 사용하는 방법의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!