前面寫過一個snabbdom的解析，vue2.0版本用的就是這個，然後在他的基礎上添加了一些功能
推薦先去看下總結：vue源碼總結
vue-clic生成項目中的render 中的 h 函數,就是createElement()
src/core/instance/render.js中創建h函數
Vue.init 的時候會調用initRender
初始化_render，
在 vm._render() 中調用了，用户傳遞的或者編譯生成的 render 函數，這個時候傳遞了 createElement。
vm.c 和 vm.$createElement 內部都調用了 createElement，不同的是最後一個參數。vm.c 在編譯生成的render 函數內部會調用，vm.$createElement 在用户傳入的 render 函數內部調用。當用户傳入render 函數的時候，要對用户傳入的參數做處理
經過前一篇vm.$mount我們知道vue 內部通過這個掛載了元素,這個方法最後執行了mountComponent方法
這個方法定義了updateComponent,updateComponent中通過vm._render()（裏面調用vm._c或者vm.$createElement）生成虛擬dom,然後vm._update對比 兩次的虛擬dom進行更新.
創建渲染Watcher時會調用一次updateComponent來渲染dom.後續屬性變化時 放入隊列的渲染watcher,最後執行run()的時候,會調用updateComponent來進行對比更新，可以結合我上一篇一起看.
然後該看vm._c和vm.$createElement也就是h函數 內部調用createElement生成vNode並返回。
createElement 類似snabbdom的h函數
我們關注重點不同部分
export function _createElement (
context: Component,
tag?: string | Class<Component> | Function | Object,
data?: VNodeData,
children?: any,
normalizationType?: number
): VNode | Array<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()
}
// <component v-bind:is="currentTabComponent"></component>
// object syntax in v-bind
if (isDef(data) && isDef(data.is)) {
tag = data.is
}
if (!tag) {
// in case of component :is set to falsy value
return createEmptyVNode()
}
// warn against non-primitive key
if (process.env.NODE_ENV !== 'production' &&
isDef(data) && isDef(data.key) && !isPrimitive(data.key)
) {
if (!__WEEX__ || !('@binding' in 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
}
if (normalizationType === ALWAYS_NORMALIZE) {
//返回一維數組，處理用户手寫的 render
//判斷children的類型，如果是原始值的話轉換成VNode的數組
//如果是數組的話，繼續處理數組中的元素
//如果數組中的子元素又是數組(slottemplate)，遞歸處理
//如果連續兩個節點都是字符串會合並文本節點
children = normalizeChildren(children)
} else if (normalizationType === SIMPLE_NORMALIZE) {
// 把二維數組，轉換成一維數組
//如果children中有函數組件的話，函數組件會返回數組形式
//這時候children就是一個二維數組，只需要把二維數組轉換為一維數組
children = simpleNormalizeChildren(children)
}
let vnode, ns
//判斷tag是字符串還是組件
if (typeof tag === 'string') {
let Ctor
ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag)
// 是否是 html 的保留標籤
if (config.isReservedTag(tag)) {
// platform built-in elements
if (process.env.NODE_ENV !== 'production' && isDef(data) && isDef(data.nativeOn)) {
warn(
`The .native modifier for v-on is only valid on components but it was used on <${tag}>.`,
context
)
}
////如果是瀏覽器的保留標籤，創建對應的VNode
vnode = new VNode(
config.parsePlatformTagName(tag), data, children,
undefined, undefined, context
)
// 判斷是否是 自定義組件
} else if ((!data || !data.pre) &&
isDef(Ctor = resolveAsset(context.$options, 'components', tag))) {
// 查找自定義組件構造函數的聲明
// 根據 Ctor 創建組件的 VNode
// 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 = new VNode(
tag, data, children,
undefined, undefined, context
)
}
} else {
// direct component options / constructor
vnode = createComponent(tag, data, context, children)
}
if (Array.isArray(vnode)) {
return vnode
} else if (isDef(vnode)) {
if (isDef(ns)) applyNS(vnode, ns)
if (isDef(data)) registerDeepBindings(data)
return vnode
} else {
return createEmptyVNode()
}
}這裏虛擬dom 和snabbdom不太一樣，vue中的vNode屬性更多,我們目前只關注我們要的就可以了（關注和snabbdom一樣）。
update方法內部調用 vm.__patch__() 把虛擬 DOM 轉換成真實 DOM
vue構造函數定義時混入時創建_update
這樣我們就知道了updateComponent中 _update(_render())，render生成虛擬dom,update對比更新，是怎樣更新的.
patch 函數初始化
功能：對比兩個 VNode 的差異，把差異更新到真實 DOM。如果是首次渲染的話，會把真實 DOM 先轉換成VNode
src/platforms/web/runtime/index.js初始化 patch
import {patch} from' ./patch'
Vue.prototype.__patch__=inBrowser?patch:noopsrc/platforms/web/runtime/patch.js
src/core/vdom/patch.js
export function createPatchFunction (backend) {
let i, j
const cbs = {}
// modules 節點的屬性/事件/樣式的操作
// nodeOps 節點操作
const { modules, nodeOps } = backend
for (i = 0; i < hooks.length; ++i) {
// cbs['update'] = []
cbs[hooks[i]] = []
for (j = 0; j < modules.length; ++j) {
if (isDef(modules[j][hooks[i]])) {
// cbs['update'] = [updateAttrs, updateClass, update...]
cbs[hooks[i]].push(modules[j][hooks[i]])
}
}
}
//........省略
return function patch (oldVnode, vnode, hydrating, removeOnly) {
// 新的 VNode 不存在
if (isUndef(vnode)) {
// 老的 VNode 存在，執行 Destroy 鈎子函數
if (isDef(oldVnode)) invokeDestroyHook(oldVnode)
return
}
let isInitialPatch = false
const insertedVnodeQueue = []
// 老的 VNode 不存在
if (isUndef(oldVnode)) {
// empty mount (likely as component), create new root element
isInitialPatch = true
// 創建新的 VNode
createElm(vnode, insertedVnodeQueue)
} else {
// 新的和老的 VNode 都存在，更新
const isRealElement = isDef(oldVnode.nodeType)
// 判斷參數1是否是真實 DOM，不是真實 DOM
if (!isRealElement && sameVnode(oldVnode, vnode)) {
// 更新操作，diff 算法
// patch existing root node
patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly)
} else {
// 第一個參數是真實 DOM，創建 VNode
// 初始化
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)
// create new node
// 創建 DOM 節點
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)
)
// 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)) {
removeVnodes([oldVnode], 0, 0)
} else if (isDef(oldVnode.tag)) {
invokeDestroyHook(oldVnode)
}
}
}
invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch)
return vnode.elm
}
}createElm把 VNode 轉換成真實 DOM，插入到 DOM 樹上這個和snabbdom的類似就不再這裏展開了,有興趣可以下源碼讀下這裏
patchVnode這裏：
function patchVnode (
oldVnode,
vnode,
insertedVnodeQueue,
ownerArray,
index,
removeOnly
) {
if (oldVnode === vnode) {
return
}
if (isDef(vnode.elm) && isDef(ownerArray)) {
// clone reused vnode
vnode = ownerArray[index] = cloneVNode(vnode)
}
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.
// 如果新舊 VNode 都是靜態的，那麼只需要替換componentInstance
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)) {
// 調用 cbs 中的鈎子函數，操作節點的屬性/樣式/事件....
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)) {
// 老節點和老節點都有有子節點
// 對子節點進行 diff 操作，調用 updateChildren
if (isDef(oldCh) && isDef(ch)) {
if (oldCh !== ch) updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly)
} else if (isDef(ch)) {
// 新的有子節點，老的沒有子節點
if (process.env.NODE_ENV !== 'production') {
checkDuplicateKeys(ch)
}
// 先清空老節點 DOM 的文本內容，然後為當前 DOM 節點加入子節點
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)
}
if (isDef(data)) {
if (isDef(i = data.hook) && isDef(i = i.postpatch)) i(oldVnode, vnode)
}
}updateChildren
updateChildren 和 Snabbdom 中的 updateChildren 整體算法一致，這裏就不再展開了。我們再來看下它處理過程中 key 的作用，再 patch 函數中，調用 patchVnode 之前，會首先調用 sameVnode()判斷當前的新老 VNode 是否是相同節點，sameVnode() 中會首先判斷 key 是否相同。
當沒有設置 key 的時候
- 在 updateChildren 中比較子節點的時候，會做三次更新 DOM 操作和一次插入 DOM 的操作
當設置 key 的時候
- 在 updateChildren 中比較子節點的時候，因為 oldVnode 的子節點的 b,c,d 和 newVnode 的 x,b,c 的key 相同，所以只做比較，沒有更新 DOM 的操作，當遍歷完畢後，會再把 x 插入到 DOM 上DOM 操作只有一次插入操作。
這是虛擬dom的更新，和snabbdom很像，就是添加了h函數中對組件部分的相關處理，根據組件編譯出來的ast語法樹,生成組件的vNode下篇我們再來了解一下vue模板的編譯瞭解下組件相關.
