解析Vue 2.5的Diff算法

dom“天生就慢”，所以前端各大框架都提供了对dom操作进行优化的办法，angular中的是脏值检查，react首先提出了virtual dom，vue2.0也加入了virtual dom，与react类似。

本文将对于vue 2.5.3版本中使用的virtual dom进行分析。

updatachildren是diff算法的核心，所以本文对updatachildren进行了图文的分析。

1.vnode对象

一个vnode的实例包含了以下属性，这部分代码在src/core/vdom/vnode.js里

export default class vnode {
 tag: string | void;
 data: vnodedata | void;
 children: ?array<vnode>;
 text: string | void;
 elm: node | void;
 ns: string | void;
 context: component | void; // rendered in this component's scope
 key: string | number | void;
 componentoptions: vnodecomponentoptions | void;
 componentinstance: component | void; // component instance
 parent: vnode | void; // component placeholder node

 // strictly internal
 raw: boolean; // contains raw html? (server only)
 isstatic: boolean; // hoisted static node
 isrootinsert: boolean; // necessary for enter transition check
 iscomment: boolean; // empty comment placeholder?
 iscloned: boolean; // is a cloned node?
 isonce: boolean; // is a v-once node?
 asyncfactory: function | void; // async component factory function
 asyncmeta: object | void;
 isasyncplaceholder: boolean;
 ssrcontext: object | void;
 functionalcontext: component | void; // real context vm for functional nodes
 functionaloptions: ?componentoptions; // for ssr caching
 functionalscopeid: ?string; // functioanl scope id support

• tag: 当前节点的标签名
• data: 当前节点的数据对象，具体包含哪些字段可以参考vue源码types/vnode.d.ts中对vnodedata的定义
• children: 数组类型，包含了当前节点的子节点
• text: 当前节点的文本，一般文本节点或注释节点会有该属性
• elm: 当前虚拟节点对应的真实的dom节点
• ns: 节点的namespace
• context: 编译作用域
• functionalcontext: 函数化组件的作用域
• key: 节点的key属性，用于作为节点的标识，有利于patch的优化
• componentoptions: 创建组件实例时会用到的选项信息
• child: 当前节点对应的组件实例
• parent: 组件的占位节点
• raw: raw html
• isstatic: 静态节点的标识
• isrootinsert: 是否作为根节点插入，被
• iscomment: 当前节点是否是注释节点
• iscloned: 当前节点是否为克隆节点
• isonce: 当前节点是否有v-once指令
  

2.vnode的分类

vnode可以理解为vuevirtual dom的一个基类，通过vnode构造函数生成的vnnode实例可为如下几类：

• emptyvnode: 没有内容的注释节点
• textvnode: 文本节点
• elementvnode: 普通元素节点
• componentvnode: 组件节点
• clonevnode: 克隆节点，可以是以上任意类型的节点，唯一的区别在于iscloned属性为true
  

3.create-element源码解析

这部分代码在src/core/vdom/create-element.js里，我就直接粘代码加上我的注释了

export function createelement (
 context: component,
 tag: any,
 data: any,
 children: any,
 normalizationtype: any,
 alwaysnormalize: boolean
): vnode {
 // 兼容不传data的情况
 if (array.isarray(data) || isprimitive(data)) {
 normalizationtype = children
 children = data
 data = undefined
 }
 // 如果alwaysnormalize是true
 // 那么normalizationtype应该设置为常量always_normalize的值
 if (istrue(alwaysnormalize)) {
 normalizationtype = always_normalize
 }
 // 调用_createelement创建虚拟节点
 return _createelement(context, tag, data, children, normalizationtype)
}

export function _createelement (
 context: component,
 tag?: string | class<component> | function | object,
 data?: vnodedata,
 children?: any,
 normalizationtype?: number
): vnode {

 /**
 * 如果存在data.__ob__，说明data是被observer观察的数据
 * 不能用作虚拟节点的data
 * 需要抛出警告，并返回一个空节点
 *
 * 被监控的data不能被用作vnode渲染的数据的原因是：
 * data在vnode渲染过程中可能会被改变，这样会触发监控，导致不符合预期的操作
 */
 if (isdef(data) && isdef((data: any).__ob__)) {
 process.env.node_env !== 'production' && warn(
  `avoid using observed data object as vnode data: ${json.stringify(data)}\n` +
  'always create fresh vnode data objects in each render!',
  context
 )
 return createemptyvnode()
 }
 // object syntax in v-bind
 if (isdef(data) && isdef(data.is)) {
 tag = data.is
 }
 if (!tag) {
 // 当组件的is属性被设置为一个falsy的值
 // vue将不会知道要把这个组件渲染成什么
 // 所以渲染一个空节点
 // in case of component :is set to falsy value
 return createemptyvnode()
 }
 // key为非原始值警告
 // warn against non-primitive key
 if (process.env.node_env !== 'production' &&
 isdef(data) && isdef(data.key) && !isprimitive(data.key)
 ) {
 warn(
  'avoid using non-primitive value as key, ' +
  'use string/number value instead.',
  context
 )
 }
 // 作用域插槽
 // support single function children as default scoped slot
 if (array.isarray(children) &&
 typeof children[0] === 'function'
 ) {
 data = data || {}
 data.scopedslots = { default: children[0] }
 children.length = 0
 }
 // 根据normalizationtype的值，选择不同的处理方法
 if (normalizationtype === always_normalize) {
 children = normalizechildren(children)
 } else if (normalizationtype === simple_normalize) {
 children = simplenormalizechildren(children)
 }
 let vnode, ns
 // 如果标签名是字符串类型
 if (typeof tag === 'string') {
 let ctor
 // 获取标签的命名空间
 ns = (context.$vnode && context.$vnode.ns) || config.gettagnamespace(tag)
 // 如果是保留标签
 if (config.isreservedtag(tag)) {
  // platform built-in elements
  // 就创建这样一个vnode
  vnode = new vnode(
  config.parseplatformtagname(tag), data, children,
  undefined, undefined, context
  )
  // 如果不是保留字标签，尝试从vm的components上查找是否有这个标签的定义
 } else if (isdef(ctor = resolveasset(context.$options, 'components', tag))) {
  // component
  // 如果找到，就创建虚拟组件节点
  vnode = createcomponent(ctor, data, context, children, tag)
 } else {
  // unknown or unlisted namespaced elements
  // check at runtime because it may get assigned a namespace when its
  // parent normalizes children
  // 兜底方案，创建一个正常的vnode
  vnode = new vnode(
  tag, data, children,
  undefined, undefined, context
  )
 }
 } else {
 // 当tag不是字符串的时候，我们认为tag是组件的构造类
 // 所以直接创建
 // direct component options / constructor
 vnode = createcomponent(tag, data, context, children)
 }
 if (isdef(vnode)) {
 // 应用命名空间
 if (ns) applyns(vnode, ns)
 return vnode
 } else {
 // 返回一个空节点
 return createemptyvnode()
 }
}
function applyns (vnode, ns, force) {
 vnode.ns = ns
 if (vnode.tag === 'foreignobject') {
 // use default namespace inside foreignobject
 ns = undefined
 force = true
 }
 if (isdef(vnode.children)) {
 for (let i = 0, l = vnode.children.length; i < l; i++) {
  const child = vnode.children[i]
  if (isdef(child.tag) && (isundef(child.ns) || istrue(force))) {
  applyns(child, ns, force)
  }
 }
 }
}

4.patch原理

patch函数的定义在src/core/vdom/patch.js中，patch逻辑比较简单，就不粘代码了

patch函数接收6个参数：

• oldvnode: 旧的虚拟节点或旧的真实dom节点
• vnode: 新的虚拟节点
• hydrating: 是否要跟真是dom混合
• removeonly: 特殊flag，用于
• parentelm: 父节点
• refelm: 新节点将插入到refelm之前

patch的逻辑是：

if vnode不存在但是oldvnode存在，说明意图是要销毁老节点，那么就调用invokedestroyhook(oldvnode)来进行销

if oldvnode不存在但是vnode存在，说明意图是要创建新节点，那么就调用createelm来创建新节点

else 当vnode和oldvnode都存在时

if oldvnode和vnode是同一个节点，就调用patchvnode来进行patch

当vnode和oldvnode不是同一个节点时，如果oldvnode是真实dom节点或hydrating设置为true，需要用hydrate函数将虚拟dom和真是dom进行映射，然后将oldvnode设置为对应的虚拟dom，找到oldvnode.elm的父节点，根据vnode创建一个真实dom节点并插入到该父节点中oldvnode.elm的位置

patchvnode的逻辑是：

1.如果oldvnode跟vnode完全一致，那么不需要做任何事情

2.如果oldvnode跟vnode都是静态节点，且具有相同的key，当vnode是克隆节点或是v-once指令控制的节点时，只需要把oldvnode.elm和oldvnode.child都复制到vnode上，也不用再有其他操作

3.否则，如果vnode不是文本节点或注释节点

• 如果oldvnode和vnode都有子节点，且2方的子节点不完全一致，就执行updatechildren
• 如果只有oldvnode有子节点，那就把这些节点都删除
• 如果只有vnode有子节点，那就创建这些子节点
• 如果oldvnode和vnode都没有子节点，但是oldvnode是文本节点或注释节点，就把vnode.elm的文本设置为空字符串

4.如果vnode是文本节点或注释节点，但是vnode.text != oldvnode.text时，只需要更新vnode.elm的文本内容就可以

代码如下：

 function patchvnode (oldvnode, vnode, insertedvnodequeue, removeonly) {
 // 如果新旧节点一致，什么都不做
 if (oldvnode === vnode) {
  return
 }
 // 让vnode.el引用到现在的真实dom，当el修改时，vnode.el会同步变化
 const elm = vnode.elm = oldvnode.elm
 // 异步占位符
 if (istrue(oldvnode.isasyncplaceholder)) {
  if (isdef(vnode.asyncfactory.resolved)) {
  hydrate(oldvnode.elm, vnode, insertedvnodequeue)
  } else {
  vnode.isasyncplaceholder = true
  }
  return
 }
 // reuse element for static trees.
 // note we only do this if the vnode is cloned -
 // if the new node is not cloned it means the render functions have been
 // reset by the hot-reload-api and we need to do a proper re-render.
 // 如果新旧都是静态节点，并且具有相同的key
 // 当vnode是克隆节点或是v-once指令控制的节点时，只需要把oldvnode.elm和oldvnode.child都复制到vnode上
 // 也不用再有其他操作
 if (istrue(vnode.isstatic) &&
  istrue(oldvnode.isstatic) &&
  vnode.key === oldvnode.key &&
  (istrue(vnode.iscloned) || istrue(vnode.isonce))
 ) {
  vnode.componentinstance = oldvnode.componentinstance
  return
 }
 let i
 const data = vnode.data
 if (isdef(data) && isdef(i = data.hook) && isdef(i = i.prepatch)) {
  i(oldvnode, vnode)
 }
 const oldch = oldvnode.children
 const ch = vnode.children
 if (isdef(data) && ispatchable(vnode)) {
  for (i = 0; i < cbs.update.length; ++i) cbs.update[i](oldvnode, vnode)
  if (isdef(i = data.hook) && isdef(i = i.update)) i(oldvnode, vnode)
 }
 // 如果vnode不是文本节点或者注释节点
 if (isundef(vnode.text)) {
  // 并且都有子节点
  if (isdef(oldch) && isdef(ch)) {
  // 并且子节点不完全一致，则调用updatechildren
  if (oldch !== ch) updatechildren(elm, oldch, ch, insertedvnodequeue, removeonly)
  // 如果只有新的vnode有子节点
  } else if (isdef(ch)) {
  if (isdef(oldvnode.text)) nodeops.settextcontent(elm, '')
  // elm已经引用了老的dom节点，在老的dom节点上添加子节点
  addvnodes(elm, null, ch, 0, ch.length - 1, insertedvnodequeue)
  // 如果新vnode没有子节点，而vnode有子节点，直接删除老的oldch
  } else if (isdef(oldch)) {
  removevnodes(elm, oldch, 0, oldch.length - 1)
  // 如果老节点是文本节点
  } else if (isdef(oldvnode.text)) {
  nodeops.settextcontent(elm, '')
  }
  // 如果新vnode和老vnode是文本节点或注释节点
  // 但是vnode.text != oldvnode.text时，只需要更新vnode.elm的文本内容就可以
 } else if (oldvnode.text !== vnode.text) {
  nodeops.settextcontent(elm, vnode.text)
 }
 if (isdef(data)) {
  if (isdef(i = data.hook) && isdef(i = i.postpatch)) i(oldvnode, vnode)
 }
 }

5.updatachildren原理

updatechildren的逻辑是：

分别获取oldvnode和vnode的firstchild、lastchild，赋值给oldstartvnode、oldendvnode、newstartvnode、newendvnode

如果oldstartvnode和newstartvnode是同一节点，调用patchvnode进行patch，然后将oldstartvnode和newstartvnode都设置为下一个子节点，

如果oldendvnode和newendvnode是同一节点，调用patchvnode进行patch，然后将oldendvnode和newendvnode都设置为上一个子节点，重复上述流程

如果oldstartvnode和newendvnode是同一节点，调用patchvnode进行patch，如果removeonly是false，那么可以把oldstartvnode.elm移动到oldendvnode.elm之后，然后把oldstartvnode设置为下一个节点，newendvnode设置为上一个节点，重复上述流程

如果newstartvnode和oldendvnode是同一节点，调用patchvnode进行patch，如果removeonly是false，那么可以把oldendvnode.elm移动到oldstartvnode.elm之前，然后把newstartvnode设置为下一个节点，oldendvnode设置为上一个节点，重复上述流程

如果以上都不匹配，就尝试在oldchildren中寻找跟newstartvnode具有相同key的节点，如果找不到相同key的节点，说明newstartvnode是一个新节点，就创建一个，然后把newstartvnode设置为下一个节点

如果上一步找到了跟newstartvnode相同key的节点，那么通过其他属性的比较来判断这2个节点是否是同一个节点，如果是，就调用patchvnode进行patch，如果removeonly是false，就把newstartvnode.elm插入到oldstartvnode.elm之前，把newstartvnode设置为下一个节点，重复上述流程

如果在oldchildren中没有寻找到newstartvnode的同一节点，那就创建一个新节点，把newstartvnode设置为下一个节点，重复上述流程

如果oldstartvnode跟oldendvnode重合了，并且newstartvnode跟newendvnode也重合了，这个循环就结束了

具体代码如下：

function updatechildren (parentelm, oldch, newch, insertedvnodequeue, removeonly) {
 let oldstartidx = 0 // 旧头索引
 let newstartidx = 0 // 新头索引
 let oldendidx = oldch.length - 1 // 旧尾索引
 let newendidx = newch.length - 1 // 新尾索引
 let oldstartvnode = oldch[0] // oldvnode的第一个child
 let oldendvnode = oldch[oldendidx] // oldvnode的最后一个child
 let newstartvnode = newch[0] // newvnode的第一个child
 let newendvnode = newch[newendidx] // newvnode的最后一个child
 let oldkeytoidx, idxinold, vnodetomove, refelm
 // removeonly is a special flag used only by <transition-group>
 // to ensure removed elements stay in correct relative positions
 // during leaving transitions
 const canmove = !removeonly
 // 如果oldstartvnode和oldendvnode重合，并且新的也都重合了，证明diff完了，循环结束
 while (oldstartidx <= oldendidx && newstartidx <= newendidx) {
  // 如果oldvnode的第一个child不存在
  if (isundef(oldstartvnode)) {
  // oldstart索引右移
  oldstartvnode = oldch[++oldstartidx] // vnode has been moved left
  // 如果oldvnode的最后一个child不存在
  } else if (isundef(oldendvnode)) {
  // oldend索引左移
  oldendvnode = oldch[--oldendidx]
  // oldstartvnode和newstartvnode是同一个节点
  } else if (samevnode(oldstartvnode, newstartvnode)) {
  // patch oldstartvnode和newstartvnode， 索引左移，继续循环
  patchvnode(oldstartvnode, newstartvnode, insertedvnodequeue)
  oldstartvnode = oldch[++oldstartidx]
  newstartvnode = newch[++newstartidx]
  // oldendvnode和newendvnode是同一个节点
  } else if (samevnode(oldendvnode, newendvnode)) {
  // patch oldendvnode和newendvnode，索引右移，继续循环
  patchvnode(oldendvnode, newendvnode, insertedvnodequeue)
  oldendvnode = oldch[--oldendidx]
  newendvnode = newch[--newendidx]
  // oldstartvnode和newendvnode是同一个节点
  } else if (samevnode(oldstartvnode, newendvnode)) { // vnode moved right
  // patch oldstartvnode和newendvnode
  patchvnode(oldstartvnode, newendvnode, insertedvnodequeue)
  // 如果removeonly是false，则将oldstartvnode.eml移动到oldendvnode.elm之后
  canmove && nodeops.insertbefore(parentelm, oldstartvnode.elm, nodeops.nextsibling(oldendvnode.elm))
  // oldstart索引右移，newend索引左移
  oldstartvnode = oldch[++oldstartidx]
  newendvnode = newch[--newendidx]
  // 如果oldendvnode和newstartvnode是同一个节点
  } else if (samevnode(oldendvnode, newstartvnode)) { // vnode moved left
  // patch oldendvnode和newstartvnode
  patchvnode(oldendvnode, newstartvnode, insertedvnodequeue)
  // 如果removeonly是false，则将oldendvnode.elm移动到oldstartvnode.elm之前
  canmove && nodeops.insertbefore(parentelm, oldendvnode.elm, oldstartvnode.elm)
  // oldend索引左移，newstart索引右移
  oldendvnode = oldch[--oldendidx]
  newstartvnode = newch[++newstartidx]
  // 如果都不匹配
  } else {
  if (isundef(oldkeytoidx)) oldkeytoidx = createkeytooldidx(oldch, oldstartidx, oldendidx)
  // 尝试在oldchildren中寻找和newstartvnode的具有相同的key的vnode
  idxinold = isdef(newstartvnode.key)
   ? oldkeytoidx[newstartvnode.key]
   : findidxinold(newstartvnode, oldch, oldstartidx, oldendidx)
  // 如果未找到，说明newstartvnode是一个新的节点
  if (isundef(idxinold)) { // new element
   // 创建一个新vnode
   createelm(newstartvnode, insertedvnodequeue, parentelm, oldstartvnode.elm)
  // 如果找到了和newstartvnodej具有相同的key的vnode，叫vnodetomove
  } else {
   vnodetomove = oldch[idxinold]
   /* istanbul ignore if */
   if (process.env.node_env !== 'production' && !vnodetomove) {
   warn(
    'it seems there are duplicate keys that is causing an update error. ' +
    'make sure each v-for item has a unique key.'
   )
   }
   // 比较两个具有相同的key的新节点是否是同一个节点
   //不设key，newch和oldch只会进行头尾两端的相互比较，设key后，除了头尾两端的比较外，还会从用key生成的对象oldkeytoidx中查找匹配的节点，所以为节点设置key可以更高效的利用dom。
   if (samevnode(vnodetomove, newstartvnode)) {
   // patch vnodetomove和newstartvnode
   patchvnode(vnodetomove, newstartvnode, insertedvnodequeue)
   // 清除
   oldch[idxinold] = undefined
   // 如果removeonly是false，则将找到的和newstartvnodej具有相同的key的vnode，叫vnodetomove.elm
   // 移动到oldstartvnode.elm之前
   canmove && nodeops.insertbefore(parentelm, vnodetomove.elm, oldstartvnode.elm)
   // 如果key相同，但是节点不相同，则创建一个新的节点
   } else {
   // same key but different element. treat as new element
   createelm(newstartvnode, insertedvnodequeue, parentelm, oldstartvnode.elm)
   }
  }
  // 右移
  newstartvnode = newch[++newstartidx]
  }
 }

6.具体的diff分析

不设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的后边了。

2.当oldendvnode，newstartvnode值得比较，oldendvnode.el跑到了oldstartvnode.el的前边，准确的说应该是oldendvnode.el需要移动到oldstartvnode.el的前边”。

3.newch中的节点oldch里没有， 将新节点插入到oldstartvnode.el的前边

在结束时，分为两种情况：

1.oldstartidx > oldendidx，可以认为oldch先遍历完。当然也有可能newch此时也正好完成了遍历，统一都归为此类。此时newstartidx和newendidx之间的vnode是新增的，调用addvnodes，把他们全部插进before的后边，before很多时候是为null的。addvnodes调用的是insertbefore操作dom节点，我们看看insertbefore的文档：parentelement.insertbefore(newelement, referenceelement)

如果referenceelement为null则newelement将被插入到子节点的末尾。如果newelement已经在dom树中，newelement首先会从dom树中移除。所以before为null，newelement将被插入到子节点的末尾。

2.newstartidx > newendidx，可以认为newch先遍历完。此时oldstartidx和oldendidx之间的vnode在新的子节点里已经不存在了，调用removevnodes将它们从dom里删除

总结

以上所述是小编给大家介绍的解析vue 2.5的diff算法，希望对大家有所帮助