如有理解不到位的地方 歡迎指正
前置步驟
render.js,
1: 執(zhí)行render方法，生成虛擬節(jié)點(diǎn)傳給了lifeCycle中的update方法
vnode = render.call(vm._renderProxy, vm.$createElement)
2:在lifecycle.js文件中
prevVnode保存上次保留的vm._vnode,第一次渲染的時(shí)候不存在就去調(diào)用vm.patch(vm.$el, vnode, hydrating, false /* removeOnly */)初始化，
后續(xù)有prevVnode就走vm.patch(prevVnode, vnode)去做更新（做diff）
export function lifecycleMixin (Vue: Class<Component>) {
Vue.prototype._update = function (vnode: VNode, hydrating?: boolean) {
const vm: Component = this
const prevEl = vm.$el
const prevVnode = vm._vnode // 第一次渲染 prevVnode不存在的
const restoreActiveInstance = setActiveInstance(vm)
vm._vnode = vnode // 首次渲染 會(huì)把vnode掛載到vm._vnode上
// Vue.prototype.__patch__ is injected in entry points
// based on the rendering backend used.
if (!prevVnode) {
// initial render patch方法 做的是初始化渲染邏輯
vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */)
} else {
// updates
vm.$el = vm.__patch__(prevVnode, vnode)
}
}
//.....
}
正式進(jìn)入比對(duì)流程
源碼都在目錄下： vdom/patch.js
（如果是真實(shí)的節(jié)點(diǎn) 并把內(nèi)容塞到老的后邊一個(gè)，刪除老的）patch?
（是相同根節(jié)點(diǎn)進(jìn)入兒子情況的判斷）?patchVnode?
（如果兩個(gè)節(jié)點(diǎn)都有兒子）?updateChildren
1：在createPatchFunction方法中return了一個(gè)patch方法
return function patch (oldVnode, vnode, hydrating, removeOnly) {
// 如果傳入 patch(oldVnode,null); 進(jìn)行卸載
if (isUndef(vnode)) {
if (isDef(oldVnode)) invokeDestroyHook(oldVnode)
return
}
let isInitialPatch = false
const insertedVnodeQueue = []
if (isUndef(oldVnode)) { // patch(vnode); // 組件的掛載 只傳一個(gè)參數(shù)
// empty mount (likely as component), create new root element
isInitialPatch = true
createElm(vnode, insertedVnodeQueue)
} else {
const isRealElement = isDef(oldVnode.nodeType)
//不是真實(shí)元素并且是相同節(jié)點(diǎn) 比較兒子的情況 （insertedVnodeQueue是做生命周期的）
if (!isRealElement && sameVnode(oldVnode, vnode)) {
// patch existing root node 核心：兩個(gè)節(jié)點(diǎn)的比較
patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly)
} else {
//如果是真實(shí)元素
if (isRealElement) {
// mounting to a real element
// check if this is server-rendered content and if we can perform
// a successful hydration.
if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
oldVnode.removeAttribute(SSR_ATTR)
hydrating = true
}
if (isTrue(hydrating)) {
if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
invokeInsertHook(vnode, insertedVnodeQueue, true)
return oldVnode
} else if (process.env.NODE_ENV !== 'production') {
warn(
'The client-side rendered virtual DOM tree is not matching ' +
'server-rendered content. This is likely caused by incorrect ' +
'HTML markup, for example nesting block-level elements inside ' +
'<p>, or missing <tbody>. Bailing hydration and performing ' +
'full client-side render.'
)
}
}
// either not server-rendered, or hydration failed.
// create an empty node and replace it
oldVnode = emptyNodeAt(oldVnode)
}
// replacing existing element
const oldElm = oldVnode.elm
const parentElm = nodeOps.parentNode(oldElm)
//根據(jù)虛擬節(jié)點(diǎn)創(chuàng)造新的節(jié)點(diǎn) 并把內(nèi)容塞到老的后邊一個(gè)
// create new node
createElm(
vnode,
insertedVnodeQueue,
// extremely rare edge case: do not insert if old element is in a
// leaving transition. Only happens when combining transition +
// keep-alive + HOCs. (#4590)
oldElm._leaveCb ? null : parentElm,
nodeOps.nextSibling(oldElm)
)
//遞歸更新節(jié)點(diǎn)
// update parent placeholder node element, recursively
if (isDef(vnode.parent)) {
let ancestor = vnode.parent
const patchable = isPatchable(vnode)
while (ancestor) {
for (let i = 0; i < cbs.destroy.length; ++i) {
cbs.destroy[i](ancestor)
}
ancestor.elm = vnode.elm
if (patchable) {
for (let i = 0; i < cbs.create.length; ++i) {
cbs.create[i](emptyNode, ancestor)
}
// #6513
// invoke insert hooks that may have been merged by create hooks.
// e.g. for directives that uses the "inserted" hook.
const insert = ancestor.data.hook.insert
if (insert.merged) {
// start at index 1 to avoid re-invoking component mounted hook
for (let i = 1; i < insert.fns.length; i++) {
insert.fns[i]()
}
}
} else {
registerRef(ancestor)
}
ancestor = ancestor.parent
}
}
// destroy old node
if (isDef(parentElm)) {
//刪除老的節(jié)點(diǎn)
removeVnodes([oldVnode], 0, 0)
} else if (isDef(oldVnode.tag)) {
invokeDestroyHook(oldVnode)
}
}
}
invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch)
return vnode.elm
}
- 2 核心在于新老的節(jié)點(diǎn)都有兒子，進(jìn)行兒子的比較 updateChildren
function patchVnode (
oldVnode,
vnode,
insertedVnodeQueue,
ownerArray,
index,
removeOnly
) {
if (oldVnode === vnode) { // 新的和老的一樣 就不用比對(duì)了 基本上不會(huì)出現(xiàn)
return
}
if (isDef(vnode.elm) && isDef(ownerArray)) {
// clone reused vnode 虛擬節(jié)點(diǎn)copy 使用
vnode = ownerArray[index] = cloneVNode(vnode)
}
const elm = vnode.elm = oldVnode.elm // 兩個(gè)節(jié)點(diǎn)一樣 節(jié)點(diǎn)的拷貝
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.
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)
}
//復(fù)用完節(jié)點(diǎn)
const oldCh = oldVnode.children // 老兒子
const ch = vnode.children // 新的兒子
if (isDef(data) && isPatchable(vnode)) {
// 調(diào)用更新邏輯 包含 當(dāng)前樣式更新， 指令的更新
// cb以此調(diào)用比對(duì)方法，更新邏輯在運(yùn)行時(shí)platform/modules下邊的屬性類等的比對(duì)方法
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)
}
if (isUndef(vnode.text)) { // 如果不是文本 并且兩個(gè)人都有內(nèi)容
if (isDef(oldCh) && isDef(ch)) { // 兩個(gè)兒子的比對(duì)
if (oldCh !== ch) updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly)
} else if (isDef(ch)) { // 新的有兒子 那么老的就沒兒子
if (process.env.NODE_ENV !== 'production') {
checkDuplicateKeys(ch)
}
// 將文本清空 添加新兒子
if (isDef(oldVnode.text)) nodeOps.setTextContent(elm, '')
// 添加兒子
addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue)
} else if (isDef(oldCh)) { // 如果老的有兒子 ，新的沒兒子
removeVnodes(oldCh, 0, oldCh.length - 1) // 刪除老兒子
} else if (isDef(oldVnode.text)) { //老的是文本清空
nodeOps.setTextContent(elm, '')
}
} else if (oldVnode.text !== vnode.text) {
nodeOps.setTextContent(elm, vnode.text) // 更新文本內(nèi)容
}
if (isDef(data)) { // 如果是組件 會(huì)去調(diào)用組件的postpatch 方法
if (isDef(i = data.hook) && isDef(i = i.postpatch)) i(oldVnode, vnode)
}
}
- 3 diff雙指針比較
首先是特殊情況頭頭比對(duì)；尾尾對(duì)比；頭尾對(duì)比：并且把相同的節(jié)點(diǎn)移動(dòng)到右邊；尾頭對(duì)比：并且把相同的移動(dòng)到左邊
最后亂序比對(duì)，對(duì)比到相同的移動(dòng)，并且原來(lái)的位置重置為undefined(否則會(huì)造成數(shù)組塌陷)
//核心 雙指針比較
function updateChildren (parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
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
// 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
if (process.env.NODE_ENV !== 'production') {
checkDuplicateKeys(newCh)
}
while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
if (isUndef(oldStartVnode)) {
oldStartVnode = oldCh[++oldStartIdx] // Vnode has been moved left
} else if (isUndef(oldEndVnode)) {
oldEndVnode = oldCh[--oldEndIdx]
} else if (sameVnode(oldStartVnode, newStartVnode)) { // 頭頭比對(duì)
patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx)
oldStartVnode = oldCh[++oldStartIdx]
newStartVnode = newCh[++newStartIdx]
} else if (sameVnode(oldEndVnode, newEndVnode)) { // 尾尾比對(duì)
patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx)
oldEndVnode = oldCh[--oldEndIdx]
newEndVnode = newCh[--newEndIdx]
// ABCD
// BCDA
} else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right 頭尾比對(duì)
patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx)
canMove && nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm))
oldStartVnode = oldCh[++oldStartIdx]
newEndVnode = newCh[--newEndIdx]
// ABCD
// DABC
} else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left
patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx)
canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm)
oldEndVnode = oldCh[--oldEndIdx]
newStartVnode = newCh[++newStartIdx]
} else {
// 亂序比對(duì)
// 先創(chuàng)建索引
if (isUndef(oldKeyToIdx)) oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx)
idxInOld = isDef(newStartVnode.key)
? oldKeyToIdx[newStartVnode.key]
: findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx)
if (isUndef(idxInOld)) { // New element 新創(chuàng)建塞入
createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx)
} else {
vnodeToMove = oldCh[idxInOld]
//判斷是不是相同節(jié)點(diǎn)
if (sameVnode(vnodeToMove, newStartVnode)) {
//相同 比對(duì) 并且移動(dòng)和插入 置空
patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx)
oldCh[idxInOld] = undefined // 做一個(gè)占位符
canMove && nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm)
} else {
// 如果key一樣 標(biāo)簽不一樣也是一個(gè)新元素
// same key but different element. treat as new element
createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx)
}
}
//不同移動(dòng)新的節(jié)點(diǎn)
newStartVnode = newCh[++newStartIdx] // 不停的移動(dòng)新的節(jié)點(diǎn)
}
}
//
if (oldStartIdx > oldEndIdx) {
refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm
addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue)
} else if (newStartIdx > newEndIdx) {
//老的多
removeVnodes(oldCh, oldStartIdx, oldEndIdx)
}
}
