<div class='testId'>
    <p>你好</p>
    <p>歡迎光臨</p>
</div>

{
    tag: 'div',
    attributes:{
        class: ['testId']
    },
    children:[
        // p 元素
        // p 元素
    ]
}

export default class VNode {
   constructor (
    tag?: string,
    data?: VNodeData,
    children?: ?Array<VNode>,
    text?: string,
    elm?: Node,
    context?: Component,
    componentOptions?: VNodeComponentOptions,
    asyncFactory?: Function
  ) {
    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
  }

  get child (): Component | void {
    return this.componentInstance
  }
}

/*
注釋節(jié)點(diǎn)
有效屬性：{isComment: true, text: '注釋節(jié)點(diǎn)'}
*/
export const createEmptyVNode = (text: string = '') => {
  const node = new VNode()
  node.text = text
  // 注釋
  node.isComment = true
  return node
}
/*
文本節(jié)點(diǎn)
有效屬性：{text: '文本節(jié)點(diǎn)'}
*/
export function createTextVNode (val: string | number) {
  return new VNode(undefined, undefined, undefined, String(val))
}

// optimized shallow clone
// used for static nodes and slot nodes because they may be reused across
// 用于靜態(tài)節(jié)點(diǎn)和插槽節(jié)點(diǎn)
// multiple renders, cloning them avoids errors when DOM manipulations rely
// on their elm reference.
// 克隆節(jié)點(diǎn)
export function cloneVNode (vnode: VNode): VNode {
  const cloned = new VNode(
    vnode.tag,
    vnode.data,
    // #7975
    // clone children array to avoid mutating original in case of cloning
    // a child.
    vnode.children && vnode.children.slice(),
    vnode.text,
    vnode.elm,
    vnode.context,
    vnode.componentOptions,
    vnode.asyncFactory
  )
  cloned.ns = vnode.ns
  cloned.isStatic = vnode.isStatic
  cloned.key = vnode.key
  cloned.isComment = vnode.isComment
  cloned.fnContext = vnode.fnContext
  cloned.fnOptions = vnode.fnOptions
  cloned.fnScopeId = vnode.fnScopeId
  cloned.asyncMeta = vnode.asyncMeta
  // 標(biāo)記是克隆節(jié)點(diǎn)
  cloned.isCloned = true
  return cloned
}

<div>
  <p v-if="type === 'A'">
    我是節(jié)點(diǎn)A
  </p>
  <span v-else-if="type === 'B'">
    我是與A完全不同的節(jié)點(diǎn)B
  </span>
</div>

// 創(chuàng)建元素
function createElm (
  vnode,
  insertedVnodeQueue,
  parentElm,
  refElm,
  nested,
  ownerArray,
  index
) {
  if (isDef(vnode.elm) && isDef(ownerArray)) {
    // This vnode was used in a previous render!
    // now it's used as a new node, overwriting its elm would cause
    // potential patch errors down the road when it's used as an insertion
    // reference node. Instead, we clone the node on-demand before creating
    // associated DOM element for it.
    vnode = ownerArray[index] = cloneVNode(vnode);
  }

  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;
  // 有 tag 屬性，表示是元素節(jié)點(diǎn)
  if (isDef(tag)) {
    vnode.elm = vnode.ns
      ? nodeOps.createElementNS(vnode.ns, tag)
      // 創(chuàng)建元素。nodeOps 涉及到跨平臺
      : nodeOps.createElement(tag, vnode);
    setScope(vnode);

    /* istanbul ignore if */
    {
      // 遞歸創(chuàng)建子節(jié)點(diǎn)，并將子節(jié)點(diǎn)插入到父節(jié)點(diǎn)上
      createChildren(vnode, children, insertedVnodeQueue);
      if (isDef(data)) {
        invokeCreateHooks(vnode, insertedVnodeQueue);
      }
      // 將 vnode 對應(yīng)的元素插入到父元素中
      insert(parentElm, vnode.elm, refElm);
    }

  // isComment 屬性表示注釋節(jié)點(diǎn)
  } else if (isTrue(vnode.isComment)) {
    vnode.elm = nodeOps.createComment(vnode.text);
    // 插入父節(jié)點(diǎn)
    insert(parentElm, vnode.elm, refElm);
  // 否則就是子節(jié)點(diǎn)
  } else {
    vnode.elm = nodeOps.createTextNode(vnode.text);
    // 插入父節(jié)點(diǎn)
    insert(parentElm, vnode.elm, refElm);
  }
}

// 遞歸創(chuàng)建子節(jié)點(diǎn)，并將子節(jié)點(diǎn)插入到父節(jié)點(diǎn)上。vnode 表示父節(jié)點(diǎn)
function createChildren (vnode, children, insertedVnodeQueue) {
  if (Array.isArray(children)) {
    if (process.env.NODE_ENV !== 'production') {
      checkDuplicateKeys(children);
    }
    // 依次創(chuàng)建子節(jié)點(diǎn)，并將子節(jié)點(diǎn)插入到父節(jié)點(diǎn)中
    for (var i = 0; i < children.length; ++i) {
      createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
    }
  } else if (isPrimitive(vnode.text)) {
    nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
  }
}

// 刪除一組指定節(jié)點(diǎn)
function removeVnodes (parentElm, vnodes, startIdx, endIdx) {
  for (; startIdx <= endIdx; ++startIdx) {
    var ch = vnodes[startIdx];
    if (isDef(ch)) {
      if (isDef(ch.tag)) {
        removeAndInvokeRemoveHook(ch);
        invokeDestroyHook(ch);
      } else { // Text node
        // 刪除個節(jié)點(diǎn)
        removeNode(ch.elm);
      }
    }
  }
}

// 刪除單個節(jié)點(diǎn)
function removeNode (el) {
  var parent = nodeOps.parentNode(el);
  // element may have already been removed due to v-html / v-text
  if (isDef(parent)) {
    // nodeOps里封裝了跨平臺的方法
    nodeOps.removeChild(parent, el);
  }
}