Vue源碼學習之初始化模塊init.js解析

let uid = 0

export function initMixin (Vue: Class<Component>) {
 Vue.prototype._init = function (options?: Object) {
 const vm: Component = this
 // a uid
 vm._uid = uid++

 let startTag, endTag
 /* istanbul ignore if */ 【**注：istanbul 是代碼覆蓋率檢測工具，此注釋為代碼測試用**】
 if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
 startTag = `vue-perf-init:${vm._uid}`
 endTag = `vue-perf-end:${vm._uid}`
 mark(startTag)
 }

 // a flag to avoid this being observed
 vm._isVue = true
 // merge options
 if (options && options._isComponent) {
 // optimize internal component instantiation
 // since dynamic options merging is pretty slow, and none of the
 // internal component options needs special treatment.
 initInternalComponent(vm, options)
 } else {
 vm.$options = mergeOptions(
 resolveConstructorOptions(vm.constructor),
 options || {},
 vm
 )
 }
 /* istanbul ignore else */
 if (process.env.NODE_ENV !== 'production') {
 initProxy(vm)
 } else {
 vm._renderProxy = vm
 }
 // expose real self
 vm._self = vm
 initLifecycle(vm)
 initEvents(vm)
 initRender(vm)
 callHook(vm, 'beforeCreate')
 initInjections(vm) // resolve injections before data/props
 initState(vm)
 initProvide(vm) // resolve provide after data/props
 callHook(vm, 'created')

 /* istanbul ignore if */
 if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
 vm._name = formatComponentName(vm, false)
 mark(endTag)
 measure(`${vm._name} init`, startTag, endTag)
 }

 if (vm.$options.el) {
 vm.$mount(vm.$options.el)
 }
 }
}

initLifecycle(vm) //生命周期變量初始化
initEvents(vm) //事件監聽初始化
initRender(vm) //初始化渲染
callHook(vm, 'beforeCreate') //回調鉤子beforeCreate
initInjections(vm) //初始化注入
initState(vm) // prop/data/computed/method/watch狀態初始化
initProvide(vm) // resolve provide after data/props
callHook(vm, 'created') //回調鉤子created
/* istanbul ignore if */
if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
 vm._name = formatComponentName(vm, false)
 mark(endTag)
 measure(`${vm._name} init`, startTag, endTag)
}

if (vm.$options.el) {
 vm.$mount(vm.$options.el)
}

initLifecycle(vm)
initEvents(vm)
callHook(vm, 'beforeCreate')
initState(vm)
callHook(vm, 'created')
initRender(vm) 

initLifecycle(vm)
initEvents(vm)
initRender(vm)
callHook(vm, 'beforeCreate')
initState(vm)
callHook(vm, 'created')
if (vm.$options.el) {
 vm.$mount(vm.$options.el)
}

function initLifecycle (vm: Component) {
 const options = vm.$options

 // locate first non-abstract parent
 let parent = options.parent //我理解為父實例或者父組件
 if (parent && !options.abstract) { //例子中沒有parent，斷點代碼的時候自動跳過
 while (parent.$options.abstract && parent.$parent) {
 parent = parent.$parent
 }
 parent.$children.push(vm)
 }

 vm.$parent = parent
 vm.$root = parent ? parent.$root : vm

 vm.$children = []
 vm.$refs = {}

 vm._watcher = null
 vm._inactive = null
 vm._directInactive = false
 vm._isMounted = false
 vm._isDestroyed = false
 vm._isBeingDestroyed = false
}

function initEvents (vm: Component) {
 vm._events = Object.create(null)
 vm._hasHookEvent = false
 // init parent attached events
 const listeners = vm.$options._parentListeners
 if (listeners) {
 updateComponentListeners(vm, listeners)
 }
}

function initRender (vm: Component) {
 vm._vnode = null // the root of the child tree
 vm._staticTrees = null
 const parentVnode = vm.$vnode = vm.$options._parentVnode
 const renderContext = parentVnode && parentVnode.context
 vm.$slots = resolveSlots(vm.$options._renderChildren, renderContext)
 vm.$scopedSlots = emptyObject 
 vm._c = (a, b, c, d) => createElement(vm, a, b, c, d, false) 
 vm.$createElement = (a, b, c, d) => createElement(vm, a, b, c, d, true)
 const parentData = parentVnode && parentVnode.data 
 /* istanbul ignore else */
 if (process.env.NODE_ENV !== 'production') {
 defineReactive(vm, '$attrs', parentData && parentData.attrs, () => {
 !isUpdatingChildComponent && warn(`$attrs is readonly.`, vm)
 }, true)
 defineReactive(vm, '$listeners', vm.$options._parentListeners, () => {
 !isUpdatingChildComponent && warn(`$listeners is readonly.`, vm)
 }, true)
 } else {
 defineReactive(vm, '$attrs', parentData && parentData.attrs, null, true)
 defineReactive(vm, '$listeners', vm.$options._parentListeners, null, true)
 }
}

function initInjections (vm: Component) {
 const result = resolveInject(vm.$options.inject, vm)
 if (result) {
 observerState.shouldConvert = false
 Object.keys(result).forEach(key => {
 /* istanbul ignore else */
 if (process.env.NODE_ENV !== 'production') {
 defineReactive(vm, key, result[key], () => {
 warn(
 `Avoid mutating an injected value directly since the changes will be ` +
 `overwritten whenever the provided component re-renders. ` +
 `injection being mutated: "${key}"`,
 vm
 )
 })
 } else {
 defineReactive(vm, key, result[key])
 }
 })
 observerState.shouldConvert = true
 }
}

function initState (vm: Component) {
 vm._watchers = []
 const opts = vm.$options
 if (opts.props) initProps(vm, opts.props)
 if (opts.methods) initMethods(vm, opts.methods)
 if (opts.data) {
 initData(vm)
 } else {
 observe(vm._data = {}, true /* asRootData */)
 }
 if (opts.computed) initComputed(vm, opts.computed)
 if (opts.watch && opts.watch !== nativeWatch) {
 initWatch(vm, opts.watch)
 }
}

function initProvide (vm: Component) {
 const provide = vm.$options.provide
 if (provide) {
 vm._provided = typeof provide === 'function'
 ? provide.call(vm)
 : provide
 }
}