vue2.0 加入了 virtual dom,有向 react 靠拢的意思。vue 的 diff 位于 patch.js 文件中,我的一个小框架 aoy 也同样使用此算法,该算法来源于 snabbdom,复杂度为 O(n)。 了解 diff 过程可以让我们更高效的使用框架。 本文力求以图文并茂的方式来讲明这个 diff 的过程。
如果不了解 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 的解决方案应运而生,virtual dom 很多时候都不是最优的操作,但它具有普适性,在效率、可维护性之间达平衡。 virtual dom 另一个重大意义就是提供一个中间层,js 去写 ui,ios 安卓之类的负责渲染,就像 reactNative 一样。
一篇相当经典的文章 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 当不值得比较时,新节点直接把老节点整个替换了 最后
returnvnode
patch 最后会返回 vnode,vnode 和进入 patch 之前的不同在哪? 没错,就是 vnode.el,唯一的改变就是之前 vnode.el = null, 而现在它引用的是对应的真实 dom。
- var oldVnode = patch(oldVnode, vnode)
至此完成一个 patch 过程。
两个节点值得比较时,会调用 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 种情况
代码很密集,为了形象的描述这个过程,可以看看这张图。
- 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)
- }
- }
过程可以概括为:oldCh 和 newCh 各有两个头尾的变量 StartIdx 和 EndIdx,它们的 2 个变量相互比较,一共有 4 种比较方式。如果 4 种比较都没匹配,如果设置了 key,就会用 key 进行比较,在比较的过程中,变量会往中间靠,一旦 StartIdx>EndIdx 表明 oldCh 和 newCh 至少有一个已经遍历完了,就会结束比较。
设置 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 操作:
图中假设 startIdx 遍历到 1。
在结束时,分为两种情况:
来源: https://juejin.im/post/5a4337daf265da43200384b9