快完事咯！
简单看了下patch函数，虽然不长，但是实际上很长很长，慢慢来吧，
首先来个总览：
// line-5250
// oldVnode => 原生DOM节点
// vnode => 虚拟DOM
// hydrating => undefined
// removeOnly => false
// 后面两个undefined
function patch(oldVnode, vnode, hydrating, removeOnly, parentElm, refElm) {
// 判断是否存在虚拟DOM
if (isUndef(vnode)) {
if (isDef(oldVnode)) {
invokeDestroyHook(oldVnode);
}
return
} var isInitialPatch = false;
var insertedVnodeQueue = []; if (isUndef(oldVnode)) {
// empty mount (likely as component), create new root element
// 空挂载或作为组件
isInitialPatch = true;
createElm(vnode, insertedVnodeQueue, parentElm, refElm);
} else {
var isRealElement = isDef(oldVnode.nodeType);
if (!isRealElement && sameVnode(oldVnode, vnode)) {
// patch existing root node
patchVnode(oldVnode, vnode, insertedVnodeQueue, removeOnly);
} else {
if (isRealElement) {
// 判断是否SSR
if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
oldVnode.removeAttribute(SSR_ATTR);
hydrating = true;
}
// hydrating这个到底是啥？？？？
if (isTrue(hydrating)) {
if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
invokeInsertHook(vnode, insertedVnodeQueue, true);
return oldVnode
} else {
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.'
);
}
}
// 两个都不是 新建空虚拟DOM
oldVnode = emptyNodeAt(oldVnode);
}
// 此处oldElm => div | parentElm$1 => body
var oldElm = oldVnode.elm;
var parentElm$1 = nodeOps.parentNode(oldElm);
createElm(
vnode,
insertedVnodeQueue,
// BUG：当节点处于leaving transition状态中不插入
oldElm._leaveCb ? null : parentElm$1,
// 获取相邻节点
nodeOps.nextSibling(oldElm)
); if (isDef(vnode.parent)) {
// component root element replaced.
// update parent placeholder node element, recursively
var ancestor = vnode.parent;
while (ancestor) {
ancestor.elm = vnode.elm;
ancestor = ancestor.parent;
}
if (isPatchable(vnode)) {
for (var i = 0; i < cbs.create.length; ++i) {
cbs.create[i](emptyNode, vnode.parent);
}
}
} if (isDef(parentElm$1)) {
removeVnodes(parentElm$1, [oldVnode], 0, 0);
} else if (isDef(oldVnode.tag)) {
invokeDestroyHook(oldVnode);
}
}
} invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
return vnode.elm
}
函数总共有6个形参，其中有3个为undefined，内部总共主要是条件判断，按照顺序跑下来。
一、
由于不是SSR，也没有hydrating这个参数，所以会直接创建一个空的虚拟DOM作为oldVnode，如下：
// line-4778
function emptyNodeAt(elm) {
return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm)
}
二、
接下来到了createElm方法，代码如下：
// line-4802
// vnode => 之前的虚拟DOM
// insertedVnodeQueue => [] => 空数组
// parentElm => body => 父元素
// refElm => 空白文本 => 节点的相邻元素
// nested => undefined
function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested) {
vnode.isRootInsert = !nested; // for transition enter check
if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
return
} var data = vnode.data;
var children = vnode.children;
var tag = vnode.tag;
if (isDef(tag)) {
// error检测
{
if (data && data.pre) {
inPre++;
}
// 这个错误经常见！
if (!inPre &&
!vnode.ns &&
!(config.ignoredElements.length && config.ignoredElements.indexOf(tag) > -1) &&
config.isUnknownElement(tag)
) {
warn(
'Unknown custom element: <' + tag + '> - did you ' +
'register the component correctly? For recursive components, ' +
'make sure to provide the "name" option.',
vnode.context
);
}
}
// ns???
vnode.elm = vnode.ns ?
nodeOps.createElementNS(vnode.ns, tag) :
nodeOps.createElement(tag, vnode);
setScope(vnode); /* istanbul ignore if */
{
createChildren(vnode, children, insertedVnodeQueue);
if (isDef(data)) {
invokeCreateHooks(vnode, insertedVnodeQueue);
}
insert(parentElm, vnode.elm, refElm);
} if ("development" !== 'production' && data && data.pre) {
inPre--;
}
}
// 注释
else if (isTrue(vnode.isComment)) {
vnode.elm = nodeOps.createComment(vnode.text);
insert(parentElm, vnode.elm, refElm);
}
// 处理纯文本
else {
vnode.elm = nodeOps.createTextNode(vnode.text);
insert(parentElm, vnode.elm, refElm);
}
}
函数进入就会调用createComponent进行判断，这个函数暂时看不太懂，一个分支都没有进，直接返回了undefined：
// line-4855
function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
// 获取属性
var i = vnode.data;
if (isDef(i)) {
var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
if (isDef(i = i.hook) && isDef(i = i.init)) {
i(vnode, false /* hydrating */ , parentElm, refElm);
}
// after calling the init hook, if the vnode is a child component
// it should've created a child instance and mounted it. the child
// component also has set the placeholder vnode's elm.
// in that case we can just return the element and be done.
if (isDef(vnode.componentInstance)) {
initComponent(vnode, insertedVnodeQueue);
if (isTrue(isReactivated)) {
reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
}
return true
}
}
}
下一步是跳到createElement函数，nodeOps中的方法都是自封装的DOM操作方法，超级简单。
// line-4599
function createElement$1(tagName, vnode) {
var elm = document.createElement(tagName);
if (tagName !== 'select') {
return elm
}
// 对select做特殊处理
// false or null will remove the attribute but undefined will not
if (vnode.data && vnode.data.attrs && vnode.data.attrs.multiple !== undefined) {
elm.setAttribute('multiple', 'multiple');
}
return elm
}
可以看，这个方法也就是创建一个DOM节点并返回，对select会做特殊处理，于是vnode.elm也就是个普通的DOM节点。
接下来是setScope函数(),该函数目的是给根节点添加一个特殊的ID，避免css样式影响其他模块。
这个东西我就熟悉啦，触发形式是这样：
渲染结果是这样：
这样可以保证所有的样式都是独立的，就算名字一样，后面添加的随机字符串可以保证唯一。
// line-4958
function setScope(vnode) {
var i;
var ancestor = vnode;
while (ancestor) {
if (isDef(i = ancestor.context) && isDef(i = i.$options._scopeId)) {
nodeOps.setAttribute(vnode.elm, i, '');
}
ancestor = ancestor.parent;
}
// for slot content they should also get the scopeId from the host instance.
if (isDef(i = activeInstance) &&
i !== vnode.context &&
isDef(i = i.$options._scopeId)) {
nodeOps.setAttribute(vnode.elm, i, '');
}
}
函数判断虚拟DOM是否存在_scopeId，然后对每一个节点添加对应的Id，这里没有，所以就会跳过去。
接下来调用createChildren方法，从名字也能看出来是对子节点的处理。实际上，也是对子节点或者纯文本进行递归处理：
// line-4927
function createChildren(vnode, children, insertedVnodeQueue) {
// 存在复杂子节点
if (Array.isArray(children)) {
for (var i = 0; i < children.length; ++i) {
createElm(children[i], insertedVnodeQueue, vnode.elm, null, true);
}
}
// 子节点为纯文本
else if (isPrimitive(vnode.text)) {
nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(vnode.text));
}
}
第一条分支处理DOM子节点，直接递归。本例子节点只是一个纯文本：
因此，重新跳入createElm方法后，会直接进入第三个分支，即：
// line-4802
function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested) {
// 属性获取
// ...
if (isDef(tag)) {
// 处理节点类型
} else if (isTrue(vnode.isComment)) {
// 处理注释
} else {
vnode.elm = nodeOps.createTextNode(vnode.text);
insert(parentElm, vnode.elm, refElm);
}
}
这个分支只有两条语句，第一条会创建一个文本节点给elm属性，第二条负责插入。
第一个DOM操作只是简单调用document.createTextNode方法，直接看第二个函数吧：
// line-4915
// parent => div => 父节点
// elm => #text => 本节点
// ref => null => 相邻节点
function insert(parent, elm, ref) {
if (isDef(parent)) {
if (isDef(ref)) {
if (ref.parentNode === parent) {
//
nodeOps.insertBefore(parent, elm, ref);
}
}
// parent.appendChild(elm)
else {
nodeOps.appendChild(parent, elm);
}
}
}
第二个也是DOM操作！好吧，比较简单，看看就懂了。
子节点处理完后，接下来处理本节点的属性，相关函数为invokeCreateHooks：
// line-4944
// vnode => 虚拟DOM
// insertedVnodeQueue => []
function invokeCreateHooks(vnode, insertedVnodeQueue) {
// cbs为工具对象
for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
cbs.create[i$1](emptyNode, vnode);
}
i = vnode.data.hook; // Reuse variable
if (isDef(i)) {
if (isDef(i.create)) {
i.create(emptyNode, vnode);
}
if (isDef(i.insert)) {
insertedVnodeQueue.push(vnode);
}
}
}
比较重要的是这里的cbs对象，在外部函数运行最开始有进行初始化，如下：
// line-4762
function createPatchFunction(backend) {
var i, j;
var cbs = {};
// line-6968
// var patch = createPatchFunction({ nodeOps: nodeOps, modules: modules });
var modules = backend.modules;
var nodeOps = backend.nodeOps; for (i = 0; i < hooks.length; ++i) {
cbs[hooks[i]] = [];
for (j = 0; j < modules.length; ++j) {
if (isDef(modules[j][hooks[i]])) {
cbs[hooks[i]].push(modules[j][hooks[i]]);
}
}
} // tools fn // return fn
}
这个对象来源于多个对象的拼接，包含大量虚拟DOM的操作方法，内容如图：
从名字可见，该对象整合了创建、摧毁、移除、更新等功能库，此处仅用create来创建，内部函数如图：
invokeCreateHooks函数一开始遍会遍历此数组，依次传参执行，参数为空vnode与当前的vnode。
这部分比较长，下次再讲。
