Start at the entrance

Start at the entrance

We mentioned Vue before JS construction process. Under the web application, let's analyze the Vue built by Runtime + Compiler JS, whose entry is Src / platforms / Web / entry runtime with compiler js:

/* @flow */

import config from 'core/config'
import { warn, cached } from 'core/util/index'
import { mark, measure } from 'core/util/perf'

import Vue from './runtime/index'
import { query } from './util/index'
import { compileToFunctions } from './compiler/index'
import { shouldDecodeNewlines, shouldDecodeNewlinesForHref } from './util/compat'

const idToTemplate = cached(id => {
  const el = query(id)
  return el && el.innerHTML

const mount = Vue.prototype.$mount
Vue.prototype.$mount = function (
  el?: string | Element,
  hydrating?: boolean
): Component {
  el = el && query(el)

  /* istanbul ignore if */
  if (el === document.body || el === document.documentElement) {
    process.env.NODE_ENV !== 'production' && warn(
      `Do not mount Vue to <html> or <body> - mount to normal elements instead.`
    return this

  const options = this.$options
  // resolve template/el and convert to render function
  if (!options.render) {
    let template = options.template
    if (template) {
      if (typeof template === 'string') {
        if (template.charAt(0) === '#') {
          template = idToTemplate(template)
          /* istanbul ignore if */
          if (process.env.NODE_ENV !== 'production' && !template) {
              `Template element not found or is empty: ${options.template}`,
      } else if (template.nodeType) {
        template = template.innerHTML
      } else {
        if (process.env.NODE_ENV !== 'production') {
          warn('invalid template option:' + template, this)
        return this
    } else if (el) {
      template = getOuterHTML(el)
    if (template) {
      /* istanbul ignore if */
      if (process.env.NODE_ENV !== 'production' && config.performance && mark) {

      const { render, staticRenderFns } = compileToFunctions(template, {
        delimiters: options.delimiters,
        comments: options.comments
      }, this)
      options.render = render
      options.staticRenderFns = staticRenderFns

      /* istanbul ignore if */
      if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
        mark('compile end')
        measure(`vue ${this._name} compile`, 'compile', 'compile end')
  return, el, hydrating)

 * Get outerHTML of elements, taking care
 * of SVG elements in IE as well.
function getOuterHTML (el: Element): string {
  if (el.outerHTML) {
    return el.outerHTML
  } else {
    const container = document.createElement('div')
    return container.innerHTML

Vue.compile = compileToFunctions

export default Vue

Then, when our code executes import Vue from 'vue', we execute the code from this entry to initialize Vue. Let's explore what Vue is and how it is initialized.

Entrance to Vue

At the top of the entry JS, we can find the source of Vue: import Vue from '/ Runtime / index ', let's take a look at the implementation of this part, which is defined in Src / platforms / Web / Runtime / index JS:

import Vue from 'core/index'
import config from 'core/config'
import { extend, noop } from 'shared/util'
import { mountComponent } from 'core/instance/lifecycle'
import { devtools, inBrowser, isChrome } from 'core/util/index'

import {
} from 'web/util/index'

import { patch } from './patch'
import platformDirectives from './directives/index'
import platformComponents from './components/index'

// install platform specific utils
Vue.config.mustUseProp = mustUseProp
Vue.config.isReservedTag = isReservedTag
Vue.config.isReservedAttr = isReservedAttr
Vue.config.getTagNamespace = getTagNamespace
Vue.config.isUnknownElement = isUnknownElement

// install platform runtime directives & components
extend(Vue.options.directives, platformDirectives)
extend(Vue.options.components, platformComponents)

// install platform patch function
Vue.prototype.__patch__ = inBrowser ? patch : noop

// public mount method
Vue.prototype.$mount = function (
  el?: string | Element,
  hydrating?: boolean
): Component {
  el = el && inBrowser ? query(el) : undefined
  return mountComponent(this, el, hydrating)

// ...

export default Vue

The key code here is to import Vue from 'core/index'. The subsequent logic is to extend the object of Vue. You don't need to look at it first. Let's take a look at the place where Vue is really initialized in Src / core / index In JS:

import Vue from './instance/index'
import { initGlobalAPI } from './global-api/index'
import { isServerRendering } from 'core/util/env'
import { FunctionalRenderContext } from 'core/vdom/create-functional-component'


Object.defineProperty(Vue.prototype, '$isServer', {
  get: isServerRendering

Object.defineProperty(Vue.prototype, '$ssrContext', {
  get () {
    /* istanbul ignore next */
    return this.$vnode && this.$vnode.ssrContext

// expose FunctionalRenderContext for ssr runtime helper installation
Object.defineProperty(Vue, 'FunctionalRenderContext', {
  value: FunctionalRenderContext

Vue.version = '__VERSION__'

export default Vue

Here are two key codes, import Vue from '/ Instance / index 'and initglobal API (Vue), initializing the global Vue API (we'll talk about it later). Let's look at the first part in Src / core / instance / index JS:

Definition of Vue

import { initMixin } from './init'
import { stateMixin } from './state'
import { renderMixin } from './render'
import { eventsMixin } from './events'
import { lifecycleMixin } from './lifecycle'
import { warn } from '../util/index'

function Vue (options) {
  if (process.env.NODE_ENV !== 'production' &&
    !(this instanceof Vue)
  ) {
    warn('Vue is a constructor and should be called with the `new` keyword')


export default Vue

Here, we finally see the true face of Vue. It is actually a class implemented by Function. We can only instantiate it through new Vue.

Seeing this, some students can't help asking why Vue doesn't use the Class of ES6 to implement it? In the future, there are many function calls of xxxMixin, and Vue is passed in as a parameter. Their functions are to extend some methods to Vue's prototype (the specific details here will be introduced in later articles and will not be expanded here). Vue distributes these extensions into multiple modules according to functions, rather than realizing all in one module. This method is difficult to implement with Class. The advantage of this is that it is very convenient for code maintenance and management, and this programming skill is also worth learning.


Vue.js in the whole initialization process, in addition to extending the method to its prototype prototype, it also extends the global static method to Vue itself, which is defined in Src / core / global API / index JS:

export function initGlobalAPI (Vue: GlobalAPI) {
  // config
  const configDef = {}
  configDef.get = () => config
  if (process.env.NODE_ENV !== 'production') {
    configDef.set = () => {
        'Do not replace the Vue.config object, set individual fields instead.'
  Object.defineProperty(Vue, 'config', configDef)

  // exposed util methods.
  // NOTE: these are not considered part of the public API - avoid relying on
  // them unless you are aware of the risk.
  Vue.util = {

  Vue.set = set
  Vue.delete = del
  Vue.nextTick = nextTick

  Vue.options = Object.create(null)
  ASSET_TYPES.forEach(type => {
    Vue.options[type + 's'] = Object.create(null)

  // this is used to identify the "base" constructor to extend all plain-object
  // components with in Weex's multi-instance scenarios.
  Vue.options._base = Vue

  extend(Vue.options.components, builtInComponents)


Here are the definitions of some global methods extended on Vue. All global APIs in Vue's official website can be found here. Details will not be introduced here. We will introduce them in detail when we introduce an API in later chapters. One thing to note is that Vue The method of util exposure is best not to rely on, because it may change frequently and is unstable.


So far, the initialization process of Vue is basically introduced. The purpose of this section is to give students an intuitive understanding of what Vue is. It is essentially a Class implemented by Function. Then its prototype prototype and itself expand a series of methods and attributes. What can Vue do and how it does it? We will help you uncover the mystery of Vue layer by layer in the following chapters.

Tags: Front-end Vue.js source code analysis

Posted by swathin2 on Wed, 25 May 2022 20:51:42 +0300