Vue源码学习之初始化模块init.js解析

我们看到了vue分了很多模块（initmixin()statemixin()eventsmixin()lifecyclemixin()rendermixin()），通过使用mixin模式，都是使用了javascript原型继承的原理，在vue的原型上面增加属性和方法。我们继续跟着this._init(options)走，这个一点击进去就知道了是进入了init.js文件是在initmixin函数里面给vue原型添加的_init方法。首先来从宏观看看这个init文件，可以看出主要是导出了两个函数：initmixin和resolveconstructoroptions，具体作用我们一步步来讨论。咋的一看这个文件，可能有些童鞋会看不明白函数参数括号里面写的是什么鬼，这个其实是应用了flow的类型检查，具体flow的使用这里就不介绍了，有兴趣的请移步：

我们现在来看第一个函数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判断工作我们可以先不细化讨论，大致第一个是用performance做性能监测，第二个合并option，第三个是做代理拦截，是es6新特性，可参考阮一峰大神关于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到此结束，以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。