diff 对象是虚拟 dom 的解析

constructor (

。。。

) {

this.tag = tag

this.data = data

this.children = children

this.text = text

this.elm = elm

this.ns = undefined

this.context = context

this.fnContext = undefined

this.fnOptions = undefined

this.fnScopeId = undefined

this.key = data && data.key

this.componentOptions = componentOptions

this.componentInstance = undefined

this.parent = undefined

this.raw = false

this.isStatic = false

this.isrootInsert = true

this.isComment = false

this.isCloned = false

this.isOnce = false

this.asyncFactory = asyncFactory

this.asyncMeta = undefined

this.isAsyncPlaceholder = false

}

function sameVnode (a, b) {

return (

a.key === b.key && (

(

a.tag === b.tag &&

a.isComment === b.isComment &&

isDef(a.data) === isDef(b.data) &&

sameInputType(a, b)

) || (

isTrue(a.isAsyncPlaceholder) &&

a.asyncFactory === b.asyncFactory &&

isUndef(b.asyncFactory.error)

)

)

)

}

export interface VNodeData {

key?: string | number;

slot?: string;

scopedSlots?: { [key: string]: ScopedSlot };

ref?: string;

tag?: string;

staticClass?: string;

class?: any;

staticStyle?: { [key: string]: any };

style?: object[] | object;

props?: { [key: string]: any };

attrs?: { [key: string]: any };

domProps?: { [key: string]: any };

hook?: { [key: string]: Function };

on?: { [key: string]: Function | Function[] };

nativeOn?: { [key: string]: Function | Function[] };

transition?: object;

show?: boolean;

inlineTemplate?: {

render: Function;

staticRenderFns: Function[];

};

directives?: VNodeDirective[];

keepAlive?: boolean;

}

// destroy old node

if (isDef(parentElm)) {

removeVnodes(parentElm, [oldVnode], 0, 0)

} else if (isDef(oldVnode.tag)) {

invokeDestroyHook(oldVnode)

}

function insert (parent, elm, ref) {

if (isDef(parent)) {

if (isDef(ref)) {

if (ref.parentNode === parent) {

nodeOps.insertBefore(parent, elm, ref)

}

} else {

nodeOps.appendChild(parent, elm)

}

}

}

function patchVnode (oldVnode, vnode, insertedVnodeQueue, removeOnly) {

if (oldVnode === vnode) {

return

}

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

}

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 <blockquote style="text-align: left;"><p style="text-align: left;">const el = vnode.el = oldVnode.el 这是很重要的一步，让vnode.el引用到现在的真实dom，当el修改时，vnode.el会同步变化。</p></blockquote><ol class=" list-paddingleft-2">

<li><p style="text-align: left;">比较二者引用是否一致</p></li>

<li><p style="text-align: left;">之后asyncFactory不知道是做什么的，所以这个比较看不懂</p></li>

<li><p style="text-align: left;"><a href="http://www.php-/wiki/188.html" target="_blank">静态</a>节点比较key，相同后也不做重新渲染，直接拷贝componentInstance（once命令在此生效）</p></li>

<li><p style="text-align: left;">如果vnode是文本节点或注释节点，但是vnode.text != oldVnode.text时，只需要更新vnode.elm的文本内容就可以</p></li>

<li><p style="text-align: left;">children的比较</p></li>

</ol>

let oldStartIdx = 0

let 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, idxInOld, vnodeToMove, refElm

while (oldStartIdx  oldEndIdx) {

refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm

addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue)

} else if (newStartIdx &gt;&nb