• 生命周期
    • beforeCreate & created
    • beforeMount & mounted
    • beforeUpdate & updated
    • beforeDestroy & destroyed
    • activated & deactivated
    • 总结

    生命周期

    每个 Vue 实例在被创建之前都要经过一系列的初始化过程。例如需要设置数据监听、编译模板、挂载实例到 DOM、在数据变化时更新 DOM 等。同时在这个过程中也会运行一些叫做生命周期钩子的函数，给予用户机会在一些特定的场景下添加他们自己的代码。
    生命周期 - 图1
    在我们实际项目开发过程中，会非常频繁地和 Vue 组件的生命周期打交道，接下来我们就从源码的角度来看一下这些生命周期的钩子函数是如何被执行的。

    源码中最终执行生命周期的函数都是调用 callHook 方法，它的定义在 src/core/instance/lifecycle 中：

    1. export function callHook (vm: Component, hook: string) {
    2.   // #7573 disable dep collection when invoking lifecycle hooks
    3.   pushTarget()
    4.   const handlers = vm.$options[hook]
    5.   if (handlers) {
    6.     for (let i = 0, j = handlers.length; i < j; i++) {
    7.       try {
    8.         handlers[i].call(vm)
    9.       } catch (e) {
    10.         handleError(e, vm, `${hook} hook`)
    11.       }
    12.     }
    13.   }
    14.   if (vm._hasHookEvent) {
    15.     vm.$emit('hook:' + hook)
    16.   }
    17.   popTarget()
    18. }

    callHook 函数的逻辑很简单，根据传入的字符串 hook，去拿到 vm.$options[hook] 对应的回调函数数组，然后遍历执行，执行的时候把 vm 作为函数执行的上下文。

    在上一节中，我们详细地介绍了 Vue.js 合并 options 的过程，各个阶段的生命周期的函数也被合并到 vm.$options 里，并且是一个数组。因此 callhook 函数的功能就是调用某个生命周期钩子注册的所有回调函数。

    了解了生命周期的执行方式后，接下来我们会具体介绍每一个生命周期函数它的调用时机。

    beforeCreate & created

    beforeCreate 和 created 函数都是在实例化 Vue 的阶段，在 _init 方法中执行的，它的定义在 src/core/instance/init.js 中：

    1. Vue.prototype._init = function (options?: Object) {
    2.   // ...
    3.   initLifecycle(vm)
    4.   initEvents(vm)
    5.   initRender(vm)
    6.   callHook(vm, 'beforeCreate')
    7.   initInjections(vm) // resolve injections before data/props
    8.   initState(vm)
    9.   initProvide(vm) // resolve provide after data/props
    10.   callHook(vm, 'created')
    11.   // ...
    12. }

    可以看到 beforeCreate 和 created 的钩子调用是在 initState 的前后，initState 的作用是初始化 props、data、methods、watch、computed 等属性，之后我们会详细分析。那么显然 beforeCreate 的钩子函数中就不能获取到 props、data 中定义的值，也不能调用 methods 中定义的函数。

    在这俩个钩子函数执行的时候，并没有渲染 DOM，所以我们也不能够访问 DOM，一般来说，如果组件在加载的时候需要和后端有交互，放在这俩个钩子函数执行都可以，如果是需要访问 props、data 等数据的话，就需要使用 created 钩子函数。之后我们会介绍 vue-router 和 vuex 的时候会发现它们都混合了 beforeCreatd 钩子函数。

    beforeMount & mounted

    顾名思义，beforeMount 钩子函数发生在 mount，也就是 DOM 挂载之前，它的调用时机是在 mountComponent 函数中，定义在 src/core/instance/lifecycle.js 中：

    1. export function mountComponent (
    2.   vm: Component,
    3.   el: ?Element,
    4.   hydrating?: boolean
    5. ): Component {
    6.   vm.$el = el
    7.   // ...
    8.   callHook(vm, 'beforeMount')
    10.   let updateComponent
    11.   /* istanbul ignore if */
    12.   if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
    13.     updateComponent = () => {
    14.       const name = vm._name
    15.       const id = vm._uid
    16.       const startTag = `vue-perf-start:${id}`
    17.       const endTag = `vue-perf-end:${id}`
    19.       mark(startTag)
    20.       const vnode = vm._render()
    21.       mark(endTag)
    22.       measure(`vue ${name} render`, startTag, endTag)
    24.       mark(startTag)
    25.       vm._update(vnode, hydrating)
    26.       mark(endTag)
    27.       measure(`vue ${name} patch`, startTag, endTag)
    28.     }
    29.   } else {
    30.     updateComponent = () => {
    31.       vm._update(vm._render(), hydrating)
    32.     }
    33.   }
    35.   // we set this to vm._watcher inside the watcher's constructor
    36.   // since the watcher's initial patch may call $forceUpdate (e.g. inside child
    37.   // component's mounted hook), which relies on vm._watcher being already defined
    38.   new Watcher(vm, updateComponent, noop, {
    39.     before () {
    40.       if (vm._isMounted) {
    41.         callHook(vm, 'beforeUpdate')
    42.       }
    43.     }
    44.   }, true /* isRenderWatcher */)
    45.   hydrating = false
    47.   // manually mounted instance, call mounted on self
    48.   // mounted is called for render-created child components in its inserted hook
    49.   if (vm.$vnode == null) {
    50.     vm._isMounted = true
    51.     callHook(vm, 'mounted')
    52.   }
    53.   return vm
    54. }

    在执行 vm._render() 函数渲染 VNode 之前，执行了 beforeMount 钩子函数，在执行完 vm._update() 把 VNode patch 到真实 DOM 后，执行 mouted 钩子。注意，这里对 mouted 钩子函数执行有一个判断逻辑，vm.$vnode 如果为 null，则表明这不是一次组件的初始化过程，而是我们通过外部 new Vue 初始化过程。那么对于组件，它的 mounted 时机在哪儿呢？

    之前我们提到过，组件的 VNode patch 到 DOM 后，会执行 invokeInsertHook 函数，把 insertedVnodeQueue 里保存的钩子函数依次执行一遍，它的定义在 src/core/vdom/patch.js 中：

    1. function invokeInsertHook (vnode, queue, initial) {
    2.   // delay insert hooks for component root nodes, invoke them after the
    3.   // element is really inserted
    4.   if (isTrue(initial) && isDef(vnode.parent)) {
    5.     vnode.parent.data.pendingInsert = queue
    6.   } else {
    7.     for (let i = 0; i < queue.length; ++i) {
    8.       queue[i].data.hook.insert(queue[i])
    9.     }
    10.   }
    11. }

    该函数会执行 insert 这个钩子函数，对于组件而言，insert 钩子函数的定义在 src/core/vdom/create-component.js 中的 componentVNodeHooks 中：

    1. const componentVNodeHooks = {
    2.   // ...
    3.   insert (vnode: MountedComponentVNode) {
    4.     const { context, componentInstance } = vnode
    5.     if (!componentInstance._isMounted) {
    6.       componentInstance._isMounted = true
    7.       callHook(componentInstance, 'mounted')
    8.     }
    9.     // ...
    10.   },
    11. }

    我们可以看到，每个子组件都是在这个钩子函数中执行 mouted 钩子函数，并且我们之前分析过，insertedVnodeQueue 的添加顺序是先子后父，所以对于同步渲染的子组件而言，mounted 钩子函数的执行顺序也是先子后父。

    beforeUpdate & updated

    顾名思义，beforeUpdate 和 updated 的钩子函数执行时机都应该是在数据更新的时候，到目前为止，我们还没有分析 Vue 的数据双向绑定、更新相关，下一章我会详细介绍这个过程。

    beforeUpdate 的执行时机是在渲染 Watcher 的 before 函数中，我们刚才提到过：

    1. export function mountComponent (
    2.   vm: Component,
    3.   el: ?Element,
    4.   hydrating?: boolean
    5. ): Component {
    6.   // ...
    8.   // we set this to vm._watcher inside the watcher's constructor
    9.   // since the watcher's initial patch may call $forceUpdate (e.g. inside child
    10.   // component's mounted hook), which relies on vm._watcher being already defined
    11.   new Watcher(vm, updateComponent, noop, {
    12.     before () {
    13.       if (vm._isMounted) {
    14.         callHook(vm, 'beforeUpdate')
    15.       }
    16.     }
    17.   }, true /* isRenderWatcher */)
    18.   // ...
    19. }

    注意这里有个判断，也就是在组件已经 mounted 之后，才会去调用这个钩子函数。

    update 的执行时机是在flushSchedulerQueue 函数调用的时候, 它的定义在 src/core/observer/scheduler.js 中：

    1. function flushSchedulerQueue () {
    2.   // ...
    3.   // 获取到 updatedQueue
    4.   callUpdatedHooks(updatedQueue)
    5. }
    7. function callUpdatedHooks (queue) {
    8.   let i = queue.length
    9.   while (i--) {
    10.     const watcher = queue[i]
    11.     const vm = watcher.vm
    12.     if (vm._watcher === watcher && vm._isMounted) {
    13.       callHook(vm, 'updated')
    14.     }
    15.   }
    16. }

    flushSchedulerQueue 函数我们之后会详细介绍，可以先大概了解一下，updatedQueue 是 更新了的 wathcer 数组，那么在 callUpdatedHooks 函数中，它对这些数组做遍历，只有满足当前 watcher 为 vm._watcher 以及组件已经 mounted 这两个条件，才会执行 updated 钩子函数。

    我们之前提过，在组件 mount 的过程中，会实例化一个渲染的 Watcher 去监听 vm 上的数据变化重新渲染，这断逻辑发生在 mountComponent 函数执行的时候：

    1. export function mountComponent (
    2.   vm: Component,
    3.   el: ?Element,
    4.   hydrating?: boolean
    5. ): Component {
    6.   // ...
    7.   // 这里是简写
    8.   let updateComponent = () => {
    9.       vm._update(vm._render(), hydrating)
    10.   }
    11.   new Watcher(vm, updateComponent, noop, {
    12.     before () {
    13.       if (vm._isMounted) {
    14.         callHook(vm, 'beforeUpdate')
    15.       }
    16.     }
    17.   }, true /* isRenderWatcher */)
    18.   // ...
    19. }

    那么在实例化 Watcher 的过程中，在它的构造函数里会判断 isRenderWatcher，接着把当前 watcher 的实例赋值给 vm._watcher，定义在 src/core/observer/watcher.js 中：

    1. export default class Watcher {
    2.   // ...
    3.   constructor (
    4.     vm: Component,
    5.     expOrFn: string | Function,
    6.     cb: Function,
    7.     options?: ?Object,
    8.     isRenderWatcher?: boolean
    9.   ) {
    10.     this.vm = vm
    11.     if (isRenderWatcher) {
    12.       vm._watcher = this
    13.     }
    14.     vm._watchers.push(this)
    15.     // ...
    16.   }
    17. }

    同时，还把当前 wathcer 实例 push 到 vm._watchers 中，vm._watcher 是专门用来监听 vm 上数据变化然后重新渲染的，所以它是一个渲染相关的 watcher，因此在 callUpdatedHooks 函数中，只有 vm._watcher 的回调执行完毕后，才会执行 updated 钩子函数。

    beforeDestroy & destroyed

    顾名思义，beforeDestroy 和 destroyed 钩子函数的执行时机在组件销毁的阶段，组件的销毁过程之后会详细介绍，最终会调用 $destroy 方法，它的定义在 src/core/instance/lifecycle.js 中：

    1. Vue.prototype.$destroy = function () {
    2.     const vm: Component = this
    3.     if (vm._isBeingDestroyed) {
    4.       return
    5.     }
    6.     callHook(vm, 'beforeDestroy')
    7.     vm._isBeingDestroyed = true
    8.     // remove self from parent
    9.     const parent = vm.$parent
    10.     if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
    11.       remove(parent.$children, vm)
    12.     }
    13.     // teardown watchers
    14.     if (vm._watcher) {
    15.       vm._watcher.teardown()
    16.     }
    17.     let i = vm._watchers.length
    18.     while (i--) {
    19.       vm._watchers[i].teardown()
    20.     }
    21.     // remove reference from data ob
    22.     // frozen object may not have observer.
    23.     if (vm._data.__ob__) {
    24.       vm._data.__ob__.vmCount--
    25.     }
    26.     // call the last hook...
    27.     vm._isDestroyed = true
    28.     // invoke destroy hooks on current rendered tree
    29.     vm.__patch__(vm._vnode, null)
    30.     // fire destroyed hook
    31.     callHook(vm, 'destroyed')
    32.     // turn off all instance listeners.
    33.     vm.$off()
    34.     // remove __vue__ reference
    35.     if (vm.$el) {
    36.       vm.$el.__vue__ = null
    37.     }
    38.     // release circular reference (#6759)
    39.     if (vm.$vnode) {
    40.       vm.$vnode.parent = null
    41.     }
    42.   }

    beforeDestroy 钩子函数的执行时机是在 $destroy 函数执行最开始的地方，接着执行了一系列的销毁动作，包括从 parent 的 $children 中删掉自身，删除 watcher，当前渲染的 VNode 执行销毁钩子函数等，执行完毕后再调用 destroy 钩子函数。

    在 $destroy 的执行过程中，它又会执行 vm.patch(vm._vnode, null) 触发它子组件的销毁钩子函数，这样一层层的递归调用，所以 destroy 钩子函数执行顺序是先子后父，和 mounted 过程一样。

    activated & deactivated

    activated 和 deactivated 钩子函数是专门为 keep-alive 组件定制的钩子，我们会在介绍 keep-alive 组件的时候详细介绍，这里先留个悬念。

    总结

    这一节主要介绍了 Vue 生命周期中各个钩子函数的执行时机以及顺序，通过分析，我们知道了如在 created 钩子函数中可以访问到数据，在 mounted 钩子函数中可以访问到 DOM，在 destroy 钩子函数中可以做一些定时器销毁工作，了解它们有利于我们在合适的生命周期去做不同的事情。

    原文: https://ustbhuangyi.github.io/vue-analysis/components/lifecycle.html