Vue源碼學習02 初始化模塊init.js

接上篇，咱們看到了VUE分了不少模塊（initMixin()stateMixin()eventsMixin()lifecycleMixin()renderMixin()），經過使用Mixin模式，都是使用了JavaScript原型繼承的原理，在Vue的原型上面增長屬性和方法。咱們繼續跟着this._init(options)走，這個一點擊進去就知道了是進入了init.js文件是在initMixin函數裏面給Vue原型添加的_init方法。首先來從宏觀看看這個init文件，能夠看出主要是導出了兩個函數：initMixin和resolveConstructorOptions，具體做用咱們一步步來討論。咋的一看這個文件，可能有些童鞋會看不明白函數參數括號裏面寫的是什麼鬼，這個實際上是應用了flow的類型檢查，具體flow的使用這裏就不介紹了，有興趣的請移步：https://flow.org/en/

咱們如今來看第一個函數initMixin，Vue實例在初始化的時候就調用了這個函數，

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)
    }
  }
}

咱們本着宏觀簡化原則，這個函數裏面前面有三個if判斷工做咱們能夠先不細化討論【有興趣可移步：http://www.cnblogs.com/QH-Jimmy/p/6862539.html】，大體第一個是用performance作性能監測，第二個合併option，第三個是作代理攔截，是ES6新特性，可參考阮一峯大神關於proxy的介紹【http://es6.ruanyifeng.com/#docs/proxy】。那麼就進入了初始化函數主要點：

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)
}

這裏來一個插曲start

V2.1.8及之前的版本】這裏比較方便理解在生命週期created以後再作render，那麼在created以前就沒法獲取DOM。這也是在有些源碼解析文章裏面很容易見到的分析，也是正確的

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

v2.1.9及之後的版本】但到這裏一開始就懵逼了好久render提到beforeCreate以前去了，那豈不是DOM在beforeCreate以前就能獲取到了？顯然不對了，請注意render雖然提早了，可是後面多了一個if這個if裏面才獲取DOM的關鍵，這個if在2.1.8版本以前是在render函數裏面的，在2.1.9以後被提出來，而後render函數提早了，至於爲什麼提早暫未了解，此處只是踩了一個看其餘源碼解析不一樣版本帶來的坑！

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

插曲end，繼續

1.initLifecycle

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
}

這個函數主要是有父實例的狀況下處理vm.$parent和vm.$children這倆個實例屬性,我此處沒有就跳過，其餘的就是新增了一些實例屬性

2.initEvents

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)
  }
}

又新增兩個屬性，後面那個if條件裏面是有父組件的事件時初始化，估計就是props和events父子組件通訊的事件內容。

3.initRender

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)
  }
}

此函數也是初始化了節點屬性信息，綁定createElement函數到實例【並未掛載】，接下來調用beforeCreate回調鉤子；——TODO1：後續專題分析VUE渲染邏輯

4.initInjections

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
  }
}

此函數也是當有inject屬性時作處理，源碼例子無inject斷點跑暫時跳過

5.initState

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)
  }
}

能夠看出此處是對options傳入的props/methods/data/computed/watch屬性作初始化————TODO2：分析每一個屬性的初始化

6.initProvide

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

這個函數跟4.initInjections在同一個inject.js中，也是在傳入參數有provide屬性時作處理，暫時跳過，而後就到了created回調鉤子，最後的vm.$mount接入TODO1；

今天initMixin到此結束，下篇繼續TODO1~