vue component initialization process

It was written in the previous article Instantiation process of vue constructor , just a rough description of the vue instance. There is no detailed description of the process of converting the vue component and virtual DOM into real Dom and page mounting. This paper mainly describes the initialization process of vue components and the conversion and mount from virtual DOM to real dom.

The instantiation of a component is similar to that of a vue constructor. The instance of a vue can be used as a root component and the instantiation of a common component can be used as a sub component. The real DOM is a tree structure, while the virtual DOM is only an abstraction of the real DOM, and also a tree structure. In short, the instantiation process of the entire vue project is as follows:


As shown in the above figure, when calling the render function, the createElement method will be called in turn. The code of the createElement method is as follows. Its main function is to generate vnode.

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!',
    return createEmptyVNode()
  // object syntax in v-bind
  if (isDef(data) && isDef( {
    tag =
  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)) {
        'Avoid using non-primitive value as key, ' +
        'use string/number value instead.',
  // 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
  // Component formatting
  if (normalizationType === ALWAYS_NORMALIZE) {
    children = normalizeChildren(children)
  } else if (normalizationType === SIMPLE_NORMALIZE) {
    children = simpleNormalizeChildren(children)
  let vnode, ns
  if (typeof tag === 'string') {
    let Ctor
    ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag)
    // Ordinary HTML Label
    if (config.isReservedTag(tag)) {
      // platform built-in elements
      if (process.env.NODE_ENV !== 'production' && isDef(data) && isDef(data.nativeOn)) {
          `The .native modifier for v-on is only valid on components but it was used on <${tag}>.`,
      // Create a normal DOM node
      vnode = new VNode(
        config.parsePlatformTagName(tag), data, children,
        undefined, undefined, context
    } else if ((!data || !data.pre) && isDef(Ctor = resolveAsset(context.$options, 'components', tag))) {
      // component
      // Create 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()
It can be seen from the above code that if there is a tag and the tag type is string, there will be some judgment logic, mainly to judge whether it is an HTML tag through config.isReservedTag, and whether it is an HTML tag through the component in the scope options of the current instance, and whether there is a declaration of the tag, even if there is a component The detailed flow chart is shown in the following figure:

As shown in the figure above, the main process is similar to the instantiation of Vue, except that in the process of instantiation of Vue, an additional branch of creating components is taken. The createComponent method is implemented as follows:

export function createComponent (
  Ctor: Class<Component> | Function | Object | void,
  data: ?VNodeData,
  context: Component,
  children: ?Array<VNode>,
  tag?: string
): VNode | Array<VNode> | void {
  if (isUndef(Ctor)) {
  // Obtain Vue Base constructor, in initGlobal Medium, will vue Basic construction method assigned to_base attribute
  const baseCtor = context.$options._base

  // plain options object: turn it into a constructor
  if (isObject(Ctor)) {
    // Combine the configuration of components into the construction method, extend Is defined in Vue In construction method
    Ctor = baseCtor.extend(Ctor)

  // if at this stage it's not a constructor or an async component factory,
  // reject.
  if (typeof Ctor !== 'function') {
    if (process.env.NODE_ENV !== 'production') {
      warn(`Invalid Component definition: ${String(Ctor)}`, context)

  // async component
  let asyncFactory
  if (isUndef(Ctor.cid)) {
    asyncFactory = Ctor
    Ctor = resolveAsyncComponent(asyncFactory, baseCtor)
    if (Ctor === undefined) {
      // return a placeholder node for async component, which is rendered
      // as a comment node but preserves all the raw information for the node.
      // the information will be used for async server-rendering and hydration.
      return createAsyncPlaceholder(

  data = data || {}

  // resolve constructor options in case global mixins are applied after
  // component constructor creation

  // transform component v-model data into props & events
  if (isDef(data.model)) {
    transformModel(Ctor.options, data)

  // extract props
  const propsData = extractPropsFromVNodeData(data, Ctor, tag)

  // functional component
  if (isTrue(Ctor.options.functional)) {
    return createFunctionalComponent(Ctor, propsData, data, context, children)

  // extract listeners, since these needs to be treated as
  // child component listeners instead of DOM listeners
  const listeners = data.on
  // replace with listeners with .native modifier
  // so it gets processed during parent component patch.
  data.on = data.nativeOn

  if (isTrue(Ctor.options.abstract)) {
    // abstract components do not keep anything
    // other than props & listeners & slot

    // work around flow
    const slot = data.slot
    data = {}
    if (slot) {
      data.slot = slot

  // install component management hooks onto the placeholder node
  // Hook function of initialization component

  // return a placeholder vnode
  // Reflects the role of component name in this
  const name = || tag
  // Establish vnode
  const vnode = new VNode(
    `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`,
    data, undefined, undefined, undefined, context,
    { Ctor, propsData, listeners, tag, children },

  // Weex specific: invoke recycle-list optimized @render function for
  // extracting cell-slot template.
  /* istanbul ignore if */
  if (__WEEX__ && isRecyclableComponent(vnode)) {
    return renderRecyclableComponentTemplate(vnode)

  return vnode

From the above code, we can see that the main function of createComponent is to return a vnode. There are two main functions of the middle process. One is to assemble the component's construction method to instantiate the component, and the other is to call installComponentHooks, which is literally to install the life cycle hook method for the component. In fact, this is the main function. Although the declaration cycle hook of the component is the same as the root instance of vue, there are still some differences in the call location, as follows:

1. The Vue construction method is in src\core\instance\index.js, and the component construction method is based on the Vue root construction method. In the above createcomponent, the Vue.extend method is called for assembly. In essence, the Vue init method on the Vue instance is called. However, the component construction method, VueComponent, declares some of its own custom properties. The specific implementation code is as follows:

 Vue.extend = function (extendOptions: Object): Function {
    extendOptions = extendOptions || {}
    const Super = this
    // Parent instance cid
    const SuperId = Super.cid
    const cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {})
    if (cachedCtors[SuperId]) {
      return cachedCtors[SuperId]

    const name = ||
    if (process.env.NODE_ENV !== 'production' && name) {
    // Definition vue Initialization methods, and instantiation Vue Take the same route
    const Sub = function VueComponent (options) {
    // super -> this -> Vue inherit Vue Properties in construction methods
    Sub.prototype = Object.create(Super.prototype)
    // Specifies that the construction method of the subcomponent is Sub -> VueComponent
    Sub.prototype.constructor = Sub
    Sub.cid = cid++
    // Merge component properties
    Sub.options = mergeOptions(
    // Define parent scope
    Sub['super'] = Super

    // For props and computed properties, we define the proxy getters on
    // the Vue instances at extension time, on the extended prototype. This
    // avoids Object.defineProperty calls for each instance created.
    if (Sub.options.props) {
    if (Sub.options.computed) {

    // allow further extension/mixin/plugin usage
    // Instances of subcomponents, keeping vue References to construction methods
    Sub.extend = Super.extend
    Sub.mixin = Super.mixin
    Sub.use = Super.use

    // create asset registers, so extended classes
    // can have their private assets too.
    ASSET_TYPES.forEach(function (type) {
      Sub[type] = Super[type]
    // enable recursive self-lookup
    if (name) {
      Sub.options.components[name] = Sub

    // keep a reference to the super options at extension time.
    // later at instantiation we can check if Super's options have
    // been updated.
    Sub.superOptions = Super.options
    Sub.extendOptions = extendOptions
    Sub.sealedOptions = extend({}, Sub.options)

    // cache constructor
    cachedCtors[SuperId] = Sub
    return Sub

2. The template resolution of the root instance of Vue is inconsistent with the DOM mount entry. In the init method, the template resolution and DOM mount of the root instance are provided, but the component is not. When creating a component, installComponentHooks is called. Component hooks mainly include init, prepatch, insert and destroy. Init is called when instantiating a component. Insert is called when inserting DOM, destroy is called when destroying a component, and prepatch is called when updating a component. The details are as follows:

const componentVNodeHooks = {
  // Component initialization method
  init (vnode: VNodeWithData, hydrating: boolean): ?boolean {
    if (
      vnode.componentInstance &&
      !vnode.componentInstance._isDestroyed &&
    ) {
      // kept-alive components, treat as a patch
      const mountedNode: any = vnode // work around flow
      componentVNodeHooks.prepatch(mountedNode, mountedNode)
    } else {
      // Instantiate component
      const child = vnode.componentInstance = createComponentInstanceForVnode(
      //Mount components
      child.$mount(hydrating ? vnode.elm : undefined, hydrating)

  prepatch (oldVnode: MountedComponentVNode, vnode: MountedComponentVNode) {
    const options = vnode.componentOptions
    const child = vnode.componentInstance = oldVnode.componentInstance
      options.propsData, // updated props
      options.listeners, // updated listeners
      vnode, // new parent vnode
      options.children // new children

  insert (vnode: MountedComponentVNode) {
    const { context, componentInstance } = vnode
    if (!componentInstance._isMounted) {
      componentInstance._isMounted = true
      callHook(componentInstance, 'mounted')
    if ( {
      if (context._isMounted) {
        // vue-router#1212
        // During updates, a kept-alive component's child components may
        // change, so directly walking the tree here may call activated hooks
        // on incorrect children. Instead we push them into a queue which will
        // be processed after the whole patch process ended.
      } else {
        activateChildComponent(componentInstance, true /* direct */)

  destroy (vnode: MountedComponentVNode) {
    const { componentInstance } = vnode
    if (!componentInstance._isDestroyed) {
      if (! {
      } else {
        deactivateChildComponent(componentInstance, true /* direct */)

As shown in the above code, the instantiation component calls createComponentInstanceForVnode, and the parsing mount template calls child.$mount. In installComponentHooks, hooks are initialized in the data attribute of vnode, and then in "patch", createComponent - > init - > instantiation component declared in patch.js will be called. After the component is instantiated, the real DOM element will be inserted into the upper level element. The createComponent method in patch.js is as follows:

  // Create a component. If the node type is a component, go directly to the method of creating a component
  function createComponent (vnode, insertedVnodeQueue, parentElm, refElm) {
    let i =
    // Determine whether there is a component life cycle, i.e. the process of creating a component needs to be followed
    if (isDef(i)) {
      const isReactivated = isDef(vnode.componentInstance) && i.keepAlive
      if (isDef(i = i.hook) && isDef(i = i.init)) {
        // implement component Of init Method to get an instance of the component
        i(vnode, false /* hydrating */)
      // 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.
      // Component vnode The scope of the current component exists in the object
      if (isDef(vnode.componentInstance)) {
        initComponent(vnode, insertedVnodeQueue)
        // Insert child component into parent node
        insert(parentElm, vnode.elm, refElm)
        if (isTrue(isReactivated)) {
          reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm)
        return true

After instantiation, the generated real DOM elements will be inserted into the parent elements. When vue obtains the real DOM, it will be added from the lower level to the upper level, and finally the rendered elements will be added to the DOM body. The main process of "patch" is as follows:

function patch (oldVnode, vnode, hydrating, removeOnly) {
    if (isUndef(vnode)) {
      if (isDef(oldVnode)) invokeDestroyHook(oldVnode)

    let isInitialPatch = false
    const insertedVnodeQueue = []

    if (isUndef(oldVnode)) {
      // empty mount (likely as component), create new root element
      isInitialPatch = true
      createElm(vnode, insertedVnodeQueue)
    } else {
      const isRealElement = isDef(oldVnode.nodeType)
      if (!isRealElement && sameVnode(oldVnode, vnode)) {
        // patch existing root node
        patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly)
      } else {
        if (isRealElement) {
          // mounting to a real element
          // check if this is server-rendered content and if we can perform
          // a successful hydration.
          // nodeType 1 Element 3 Text
          if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(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') {
                '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
        // Get old nodes
        const oldElm = oldVnode.elm
        // Get the parent of an old node
        const parentElm = nodeOps.parentNode(oldElm)

        // create new node
        // Virtual DOM Convert to reality DOM
        // Incoming parent node, level 1 add
          // 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,

        // 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) {
            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 =
              if (insert.merged) {
                // start at index 1 to avoid re-invoking component mounted hook
                for (let i = 1; i < insert.fns.length; i++) {
            } else {
            ancestor = ancestor.parent

        // destroy old node
        // Remove old nodes
        if (isDef(parentElm)) {
          removeVnodes([oldVnode], 0, 0)
        } else if (isDef(oldVnode.tag)) {

    invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch)
    return vnode.elm

Template parsing is to parse the template into HTML first, and then to remove the old nodes.


Keywords: Javascript Vue Attribute JSON github

Added by php_guy on Tue, 17 Dec 2019 13:47:38 +0200