Vuex

Vuex 是一个专为 Vue.js 应用程序开发的状态管理模式。它采用集中式存储管理应用的所有组件的状态，并以相应的规则保证状态以一种可预测的方式发生变化。

什么是“状态管理模式”？

让我们从一个简单的 Vue 计数应用开始：

  1. new Vue({
  2.   // state
  3.   data () {
  4.     return {
  5.       count: 0
  6.     }
  7.   },
  8.   // view
  9.   template: `
  10.     <div>{{ count }}</div>
  11.   `,
  12.   // actions
  13.   methods: {
  14.     increment () {
  15.       this.count++
  16.     }
  17.   }
  18. })

这个状态自管理应用包含以下几个部分：

  • state，驱动应用的数据源；
  • view，以声明方式将 state 映射到视图；
  • actions，响应在 view 上的用户输入导致的状态变化。

以下是一个表示“单向数据流”理念的极简示意：
Vuex - 图1

但是，当我们的应用遇到多个组件共享状态时，单向数据流的简洁性很容易被破坏：

  • 多个视图依赖于同一状态。
  • 来自不同视图的行为需要变更同一状态。

对于问题一，传参的方法对于多层嵌套的组件将会非常繁琐，并且对于兄弟组件间的状态传递无能为力。对于问题二，我们经常会采用父子组件直接引用或者通过事件来变更和同步状态的多份拷贝。以上的这些模式非常脆弱，通常会导致无法维护的代码。

因此，我们为什么不把组件的共享状态抽取出来，以一个全局单例模式管理呢？在这种模式下，我们的组件树构成了一个巨大的“视图”，不管在树的哪个位置，任何组件都能获取状态或者触发行为。

Vuex 核心思想

Vuex 应用的核心就是 store（仓库）。“store”基本上就是一个容器，它包含着你的应用中大部分的状态 (state)。有些同学可能会问，那我定义一个全局对象，再去上层封装了一些数据存取的接口不也可以么？

Vuex 和单纯的全局对象有以下两点不同：

  • Vuex 的状态存储是响应式的。当 Vue 组件从 store 中读取状态的时候，若 store 中的状态发生变化，那么相应的组件也会相应地得到高效更新。
  • 你不能直接改变 store 中的状态。改变 store 中的状态的唯一途径就是显式地提交 (commit) mutation。这样使得我们可以方便地跟踪每一个状态的变化，从而让我们能够实现一些工具帮助我们更好地了解我们的应用。

另外，通过定义和隔离状态管理中的各种概念并强制遵守一定的规则，我们的代码将会变得更结构化且易维护。

Vuex - 图2

Vuex 初始化

这一节我们主要来分析 Vuex 的初始化过程，它包括安装、Store 实例化过程 2 个方面。

安装

当我们在代码中通过 import Vuex from 'vuex' 的时候，实际上引用的是一个对象，它的定义在 src/index.js 中：

  1. export default {
  2.   Store,
  3.   install,
  4.   version: '__VERSION__',
  5.   mapState,
  6.   mapMutations,
  7.   mapGetters,
  8.   mapActions,
  9.   createNamespacedHelpers
  10. }

和 Vue-Router 一样，Vuex 也同样存在一个静态的 install 方法，它的定义在 src/store.js 中：

  1. export function install (_Vue) {
  2.   if (Vue && _Vue === Vue) {
  3.     if (process.env.NODE_ENV !== 'production') {
  4.       console.error(
  5.         '[vuex] already installed. Vue.use(Vuex) should be called only once.'
  6.       )
  7.     }
  8.     return
  9.   }
  10.   Vue = _Vue
  11.   applyMixin(Vue)
  12. }

install 的逻辑很简单，把传入的 _Vue 赋值给 Vue 并执行了 applyMixin(Vue) 方法，它的定义在 src/mixin.js 中：

  1. export default function (Vue) {
  2.   const version = Number(Vue.version.split('.')[0])
  4.   if (version >= 2) {
  5.     Vue.mixin({ beforeCreate: vuexInit })
  6.   } else {
  7.     // override init and inject vuex init procedure
  8.     // for 1.x backwards compatibility.
  9.     const _init = Vue.prototype._init
  10.     Vue.prototype._init = function (options = {}) {
  11.       options.init = options.init
  12.         ? [vuexInit].concat(options.init)
  13.         : vuexInit
  14.       _init.call(this, options)
  15.     }
  16.   }
  18.   /**
  19.    * Vuex init hook, injected into each instances init hooks list.
  20.    */
  22.   function vuexInit () {
  23.     const options = this.$options
  24.     // store injection
  25.     if (options.store) {
  26.       this.$store = typeof options.store === 'function'
  27.         ? options.store()
  28.         : options.store
  29.     } else if (options.parent && options.parent.$store) {
  30.       this.$store = options.parent.$store
  31.     }
  32.   }
  33. }

applyMixin 就是这个 export default function，它还兼容了 Vue 1.0 的版本，这里我们只关注 Vue 2.0 以上版本的逻辑，它其实就全局混入了一个 beforeCreate 钩子函数，它的实现非常简单，就是把 options.store 保存在所有组件的 this.$store 中，这个 options.store 就是我们在实例化 Store 对象的实例，稍后我们会介绍，这也是为什么我们在组件中可以通过 this.$store 访问到这个实例。

Store 实例化

我们在 import Vuex 之后，会实例化其中的 Store 对象，返回 store 实例并传入 new Vue 的 options 中，也就是我们刚才提到的 options.store.

举个简单的例子，如下：

  1. export default new Vuex.Store({
  2.   actions,
  3.   getters,
  4.   state,
  5.   mutations,
  6.   modules
  7.   // ...
  8. })

Store 对象的构造函数接收一个对象参数，它包含 actions、getters、state、mutations、modules 等 Vuex 的核心概念，它的定义在 src/store.js 中：

  1. export class Store {
  2.   constructor (options = {}) {
  3.     // Auto install if it is not done yet and `window` has `Vue`.
  4.     // To allow users to avoid auto-installation in some cases,
  5.     // this code should be placed here. See #731
  6.     if (!Vue && typeof window !== 'undefined' && window.Vue) {
  7.       install(window.Vue)
  8.     }
  10.     if (process.env.NODE_ENV !== 'production') {
  11.       assert(Vue, `must call Vue.use(Vuex) before creating a store instance.`)
  12.       assert(typeof Promise !== 'undefined', `vuex requires a Promise polyfill in this browser.`)
  13.       assert(this instanceof Store, `Store must be called with the new operator.`)
  14.     }
  16.     const {
  17.       plugins = [],
  18.       strict = false
  19.     } = options
  21.     // store internal state
  22.     this._committing = false
  23.     this._actions = Object.create(null)
  24.     this._actionSubscribers = []
  25.     this._mutations = Object.create(null)
  26.     this._wrappedGetters = Object.create(null)
  27.     this._modules = new ModuleCollection(options)
  28.     this._modulesNamespaceMap = Object.create(null)
  29.     this._subscribers = []
  30.     this._watcherVM = new Vue()
  32.     // bind commit and dispatch to self
  33.     const store = this
  34.     const { dispatch, commit } = this
  35.     this.dispatch = function boundDispatch (type, payload) {
  36.       return dispatch.call(store, type, payload)
  37.     }
  38.     this.commit = function boundCommit (type, payload, options) {
  39.       return commit.call(store, type, payload, options)
  40.     }
  42.     // strict mode
  43.     this.strict = strict
  45.     const state = this._modules.root.state
  47.     // init root module.
  48.     // this also recursively registers all sub-modules
  49.     // and collects all module getters inside this._wrappedGetters
  50.     installModule(this, state, [], this._modules.root)
  52.     // initialize the store vm, which is responsible for the reactivity
  53.     // (also registers _wrappedGetters as computed properties)
  54.     resetStoreVM(this, state)
  56.     // apply plugins
  57.     plugins.forEach(plugin => plugin(this))
  59.     if (Vue.config.devtools) {
  60.       devtoolPlugin(this)
  61.     }
  62.   }
  63. }

我们把 Store 的实例化过程拆成 3 个部分，分别是初始化模块，安装模块和初始化 store._vm，接下来我们来分析这 3 部分的实现。

初始化模块

在分析模块初始化之前，我们先来了解一下模块对于 Vuex 的意义：由于使用单一状态树，应用的所有状态会集中到一个比较大的对象，当应用变得非常复杂时，store 对象就有可能变得相当臃肿。为了解决以上问题，Vuex 允许我们将 store 分割成模块（module）。每个模块拥有自己的 state、mutation、action、getter，甚至是嵌套子模块——从上至下进行同样方式的分割：

  1. const moduleA = {
  2.   state: { ... },
  3.   mutations: { ... },
  4.   actions: { ... },
  5.   getters: { ... }
  6. }
  8. const moduleB = {
  9.   state: { ... },
  10.   mutations: { ... },
  11.   actions: { ... },
  12.   getters: { ... },
  13. }
  15. const store = new Vuex.Store({
  16.   modules: {
  17.     a: moduleA,
  18.     b: moduleB
  19.   }
  20. })
  22. store.state.a // -> moduleA 的状态
  23. store.state.b // -> moduleB 的状态

所以从数据结构上来看，模块的设计就是一个树型结构，store 本身可以理解为一个 root module，它下面的 modules 就是子模块，Vuex 需要完成这颗树的构建，构建过程的入口就是：

  1. this._modules = new ModuleCollection(options)

ModuleCollection 的定义在 src/module/module-collection.js 中：

  1. export default class ModuleCollection {
  2.   constructor (rawRootModule) {
  3.     // register root module (Vuex.Store options)
  4.     this.register([], rawRootModule, false)
  5.   }
  7.   get (path) {
  8.     return path.reduce((module, key) => {
  9.       return module.getChild(key)
  10.     }, this.root)
  11.   }
  13.   getNamespace (path) {
  14.     let module = this.root
  15.     return path.reduce((namespace, key) => {
  16.       module = module.getChild(key)
  17.       return namespace + (module.namespaced ? key + '/' : '')
  18.     }, '')
  19.   }
  21.   update (rawRootModule) {
  22.     update([], this.root, rawRootModule)
  23.   }
  25.   register (path, rawModule, runtime = true) {
  26.     if (process.env.NODE_ENV !== 'production') {
  27.       assertRawModule(path, rawModule)
  28.     }
  30.     const newModule = new Module(rawModule, runtime)
  31.     if (path.length === 0) {
  32.       this.root = newModule
  33.     } else {
  34.       const parent = this.get(path.slice(0, -1))
  35.       parent.addChild(path[path.length - 1], newModule)
  36.     }
  38.     // register nested modules
  39.     if (rawModule.modules) {
  40.       forEachValue(rawModule.modules, (rawChildModule, key) => {
  41.         this.register(path.concat(key), rawChildModule, runtime)
  42.       })
  43.     }
  44.   }
  46.   unregister (path) {
  47.     const parent = this.get(path.slice(0, -1))
  48.     const key = path[path.length - 1]
  49.     if (!parent.getChild(key).runtime) return
  51.     parent.removeChild(key)
  52.   }
  53. }

ModuleCollection 实例化的过程就是执行了 register 方法，
register 接收 3 个参数，其中 path 表示路径，因为我们整体目标是要构建一颗模块树，path 是在构建树的过程中维护的路径；rawModule 表示定义模块的原始配置；runtime 表示是否是一个运行时创建的模块。

register 方法首先通过 const newModule = new Module(rawModule, runtime) 创建了一个 Module 的实例，Module 是用来描述单个模块的类，它的定义在 src/module/module.js 中：

  1. export default class Module {
  2.   constructor (rawModule, runtime) {
  3.     this.runtime = runtime
  4.     // Store some children item
  5.     this._children = Object.create(null)
  6.     // Store the origin module object which passed by programmer
  7.     this._rawModule = rawModule
  8.     const rawState = rawModule.state
  10.     // Store the origin module's state
  11.     this.state = (typeof rawState === 'function' ? rawState() : rawState) || {}
  12.   }
  14.   get namespaced () {
  15.     return !!this._rawModule.namespaced
  16.   }
  18.   addChild (key, module) {
  19.     this._children[key] = module
  20.   }
  22.   removeChild (key) {
  23.     delete this._children[key]
  24.   }
  26.   getChild (key) {
  27.     return this._children[key]
  28.   }
  30.   update (rawModule) {
  31.     this._rawModule.namespaced = rawModule.namespaced
  32.     if (rawModule.actions) {
  33.       this._rawModule.actions = rawModule.actions
  34.     }
  35.     if (rawModule.mutations) {
  36.       this._rawModule.mutations = rawModule.mutations
  37.     }
  38.     if (rawModule.getters) {
  39.       this._rawModule.getters = rawModule.getters
  40.     }
  41.   }
  43.   forEachChild (fn) {
  44.     forEachValue(this._children, fn)
  45.   }
  47.   forEachGetter (fn) {
  48.     if (this._rawModule.getters) {
  49.       forEachValue(this._rawModule.getters, fn)
  50.     }
  51.   }
  53.   forEachAction (fn) {
  54.     if (this._rawModule.actions) {
  55.       forEachValue(this._rawModule.actions, fn)
  56.     }
  57.   }
  59.   forEachMutation (fn) {
  60.     if (this._rawModule.mutations) {
  61.       forEachValue(this._rawModule.mutations, fn)
  62.     }
  63.   }
  64. }

来看一下 Module 的构造函数，对于每个模块而言，this._rawModule 表示模块的配置，this._children 表示它的所有子模块，this.state 表示这个模块定义的 state。

回到 register，那么在实例化一个 Module 后，判断当前的 path 的长度如果为 0，则说明它是一个根模块，所以把 newModule 赋值给了 this.root，否则就需要建立父子关系了：

  1. const parent = this.get(path.slice(0, -1))
  2. parent.addChild(path[path.length - 1], newModule)

我们先大体上了解它的逻辑：首先根据路径获取到父模块，然后再调用父模块的 addChild 方法建立父子关系。

register 的最后一步，就是遍历当前模块定义中的所有 modules，根据 key 作为 path，递归调用 register 方法，这样我们再回过头看一下建立父子关系的逻辑，首先执行了 this.get(path.slice(0, -1) 方法：

  1. get (path) {
  2.   return path.reduce((module, key) => {
  3.     return module.getChild(key)
  4.   }, this.root)
  5. }

传入的 path 是它的父模块的 path，然后从根模块开始，通过 reduce 方法一层层去找到对应的模块，查找的过程中，执行的是 module.getChild(key) 方法：

  1. getChild (key) {
  2.   return this._children[key]
  3. }

其实就是返回当前模块的 _children 中对应 key 的模块，那么每个模块的 _children 是如何添加的呢，是通过执行 parent.addChild(path[path.length - 1], newModule) 方法：

  1. addChild (key, module) {
  2.   this._children[key] = module
  3. }

所以说对于 root module 的下一层 modules 来说，它们的 parent 就是 root module，那么他们就会被添加的 root module 的 _children 中。每个子模块通过路径找到它的父模块，然后通过父模块的 addChild 方法建立父子关系，递归执行这样的过程，最终就建立一颗完整的模块树。

安装模块

初始化模块后，执行安装模块的相关逻辑，它的目标就是对模块中的 state、getters、mutations、actions 做初始化工作，它的入口代码是：

  1. const state = this._modules.root.state
  2. installModule(this, state, [], this._modules.root)

来看一下 installModule 的定义：

  1. function installModule (store, rootState, path, module, hot) {
  2.   const isRoot = !path.length
  3.   const namespace = store._modules.getNamespace(path)
  5.   // register in namespace map
  6.   if (module.namespaced) {
  7.     store._modulesNamespaceMap[namespace] = module
  8.   }
  10.   // set state
  11.   if (!isRoot && !hot) {
  12.     const parentState = getNestedState(rootState, path.slice(0, -1))
  13.     const moduleName = path[path.length - 1]
  14.     store._withCommit(() => {
  15.       Vue.set(parentState, moduleName, module.state)
  16.     })
  17.   }
  19.   const local = module.context = makeLocalContext(store, namespace, path)
  21.   module.forEachMutation((mutation, key) => {
  22.     const namespacedType = namespace + key
  23.     registerMutation(store, namespacedType, mutation, local)
  24.   })
  26.   module.forEachAction((action, key) => {
  27.     const type = action.root ? key : namespace + key
  28.     const handler = action.handler || action
  29.     registerAction(store, type, handler, local)
  30.   })
  32.   module.forEachGetter((getter, key) => {
  33.     const namespacedType = namespace + key
  34.     registerGetter(store, namespacedType, getter, local)
  35.   })
  37.   module.forEachChild((child, key) => {
  38.     installModule(store, rootState, path.concat(key), child, hot)
  39.   })
  40. }

installModule 方法支持 5 个参数，store 表示 root store；state 表示 root state；path 表示模块的访问路径；module 表示当前的模块，hot 表示是否是热更新。

接下来看函数逻辑，这里涉及到了命名空间的概念，默认情况下，模块内部的 action、mutation 和 getter 是注册在全局命名空间的——这样使得多个模块能够对同一 mutation 或 action 作出响应。如果我们希望模块具有更高的封装度和复用性，可以通过添加 namespaced: true 的方式使其成为带命名空间的模块。当模块被注册后，它的所有 getter、action 及 mutation 都会自动根据模块注册的路径调整命名。例如：

  1. const store = new Vuex.Store({
  2.   modules: {
  3.     account: {
  4.       namespaced: true,
  6.       // 模块内容（module assets）
  7.       state: { ... }, // 模块内的状态已经是嵌套的了，使用 `namespaced` 属性不会对其产生影响
  8.       getters: {
  9.         isAdmin () { ... } // -> getters['account/isAdmin']
  10.       },
  11.       actions: {
  12.         login () { ... } // -> dispatch('account/login')
  13.       },
  14.       mutations: {
  15.         login () { ... } // -> commit('account/login')
  16.       },
  18.       // 嵌套模块
  19.       modules: {
  20.         // 继承父模块的命名空间
  21.         myPage: {
  22.           state: { ... },
  23.           getters: {
  24.             profile () { ... } // -> getters['account/profile']
  25.           }
  26.         },
  28.         // 进一步嵌套命名空间
  29.         posts: {
  30.           namespaced: true,
  32.           state: { ... },
  33.           getters: {
  34.             popular () { ... } // -> getters['account/posts/popular']
  35.           }
  36.         }
  37.       }
  38.     }
  39.   }
  40. })

回到 installModule 方法，我们首先根据 path 获取 namespace：

  1. const namespace = store._modules.getNamespace(path)

getNamespace 的定义在 src/module/module-collection.js 中：

  1. getNamespace (path) {
  2.   let module = this.root
  3.   return path.reduce((namespace, key) => {
  4.     module = module.getChild(key)
  5.     return namespace + (module.namespaced ? key + '/' : '')
  6.   }, '')
  7. }

从 root module 开始，通过 reduce 方法一层层找子模块，如果发现该模块配置了 namespaced 为 true，则把该模块的 key 拼到 namesapce 中，最终返回完整的 namespace 字符串。

回到 installModule 方法，接下来把 namespace 对应的模块保存下来，为了方便以后能根据 namespace 查找模块：

  1. if (module.namespaced) {
  2.   store._modulesNamespaceMap[namespace] = module
  3. }

接下来判断非 root module 且非 hot 的情况执行一些逻辑，我们稍后再看。

接着是很重要的逻辑，构造了一个本地上下文环境：

  1. const local = module.context = makeLocalContext(store, namespace, path)

来看一下 makeLocalContext 实现：

  1. function makeLocalContext (store, namespace, path) {
  2.   const noNamespace = namespace === ''
  4.   const local = {
  5.     dispatch: noNamespace ? store.dispatch : (_type, _payload, _options) => {
  6.       const args = unifyObjectStyle(_type, _payload, _options)
  7.       const { payload, options } = args
  8.       let { type } = args
  10.       if (!options || !options.root) {
  11.         type = namespace + type
  12.         if (process.env.NODE_ENV !== 'production' && !store._actions[type]) {
  13.           console.error(`[vuex] unknown local action type: ${args.type}, global type: ${type}`)
  14.           return
  15.         }
  16.       }
  18.       return store.dispatch(type, payload)
  19.     },
  21.     commit: noNamespace ? store.commit : (_type, _payload, _options) => {
  22.       const args = unifyObjectStyle(_type, _payload, _options)
  23.       const { payload, options } = args
  24.       let { type } = args
  26.       if (!options || !options.root) {
  27.         type = namespace + type
  28.         if (process.env.NODE_ENV !== 'production' && !store._mutations[type]) {
  29.           console.error(`[vuex] unknown local mutation type: ${args.type}, global type: ${type}`)
  30.           return
  31.         }
  32.       }
  34.       store.commit(type, payload, options)
  35.     }
  36.   }
  38.   // getters and state object must be gotten lazily
  39.   // because they will be changed by vm update
  40.   Object.defineProperties(local, {
  41.     getters: {
  42.       get: noNamespace
  43.         ? () => store.getters
  44.         : () => makeLocalGetters(store, namespace)
  45.     },
  46.     state: {
  47.       get: () => getNestedState(store.state, path)
  48.     }
  49.   })
  51.   return local
  52. }

makeLocalContext 支持 3 个参数相关，store 表示 root store；namespace 表示模块的命名空间，path 表示模块的 path。

该方法定义了 local 对象，对于 dispatch 和 commit 方法，如果没有 namespace，它们就直接指向了 root store 的 dispatch 和 commit 方法，否则会创建方法，把 type 自动拼接上 namespace，然后执行 store 上对应的方法。

对于 getters 而言，如果没有 namespace，则直接返回 root store 的 getters，否则返回 makeLocalGetters(store, namespace) 的返回值：

  1. function makeLocalGetters (store, namespace) {
  2.   const gettersProxy = {}
  4.   const splitPos = namespace.length
  5.   Object.keys(store.getters).forEach(type => {
  6.     // skip if the target getter is not match this namespace
  7.     if (type.slice(0, splitPos) !== namespace) return
  9.     // extract local getter type
  10.     const localType = type.slice(splitPos)
  12.     // Add a port to the getters proxy.
  13.     // Define as getter property because
  14.     // we do not want to evaluate the getters in this time.
  15.     Object.defineProperty(gettersProxy, localType, {
  16.       get: () => store.getters[type],
  17.       enumerable: true
  18.     })
  19.   })
  21.   return gettersProxy
  22. }

makeLocalGetters 首先获取了 namespace 的长度，然后遍历 root store 下的所有 getters，先判断它的类型是否匹配 namespace，只有匹配的时候我们从 namespace 的位置截取后面的字符串得到 localType，接着用 Object.defineProperty 定义了 gettersProxy，获取 localType 实际上是访问了 store.getters[type]。

回到 makeLocalContext 方法，再来看一下对 state 的实现，它的获取则是通过 getNestedState(store.state, path) 方法：

  1. function getNestedState (state, path) {
  2.   return path.length
  3.     ? path.reduce((state, key) => state[key], state)
  4.     : state
  5. }

getNestedState 逻辑很简单，从 root state 开始，通过 path.reduce 方法一层层查找子模块 state，最终找到目标模块的 state。

那么构造完 local 上下文后，我们再回到 installModule 方法，接下来它就会遍历模块中定义的 mutations、actions、getters，分别执行它们的注册工作，它们的注册逻辑都大同小异。

  • registerMutation
  1. module.forEachMutation((mutation, key) => {
  2.   const namespacedType = namespace + key
  3.   registerMutation(store, namespacedType, mutation, local)
  4. })
  6. function registerMutation (store, type, handler, local) {
  7.   const entry = store._mutations[type] || (store._mutations[type] = [])
  8.   entry.push(function wrappedMutationHandler (payload) {
  9.     handler.call(store, local.state, payload)
  10.   })
  11. }

首先遍历模块中的 mutations 的定义，拿到每一个 mutation 和 key，并把 key 拼接上 namespace，然后执行 registerMutation 方法。该方法实际上就是给 root store 上的 _mutations[types] 添加 wrappedMutationHandler 方法，该方法的具体实现我们之后会提到。注意，同一 type 的 _mutations 可以对应多个方法。

  • registerAction
  1. module.forEachAction((action, key) => {
  2.   const type = action.root ? key : namespace + key
  3.   const handler = action.handler || action
  4.   registerAction(store, type, handler, local)
  5. })
  7. function registerAction (store, type, handler, local) {
  8.   const entry = store._actions[type] || (store._actions[type] = [])
  9.   entry.push(function wrappedActionHandler (payload, cb) {
  10.     let res = handler.call(store, {
  11.       dispatch: local.dispatch,
  12.       commit: local.commit,
  13.       getters: local.getters,
  14.       state: local.state,
  15.       rootGetters: store.getters,
  16.       rootState: store.state
  17.     }, payload, cb)
  18.     if (!isPromise(res)) {
  19.       res = Promise.resolve(res)
  20.     }
  21.     if (store._devtoolHook) {
  22.       return res.catch(err => {
  23.         store._devtoolHook.emit('vuex:error', err)
  24.         throw err
  25.       })
  26.     } else {
  27.       return res
  28.     }
  29.   })
  30. }

首先遍历模块中的 actions 的定义，拿到每一个 action 和 key，并判断 action.root，如果否的情况把 key 拼接上 namespace，然后执行 registerAction 方法。该方法实际上就是给 root store 上的 _actions[types] 添加 wrappedActionHandler 方法，该方法的具体实现我们之后会提到。注意，同一 type 的 _actions 可以对应多个方法。

  • registerGetter
  1. module.forEachGetter((getter, key) => {
  2.   const namespacedType = namespace + key
  3.   registerGetter(store, namespacedType, getter, local)
  4. })
  7. function registerGetter (store, type, rawGetter, local) {
  8.   if (store._wrappedGetters[type]) {
  9.     if (process.env.NODE_ENV !== 'production') {
  10.       console.error(`[vuex] duplicate getter key: ${type}`)
  11.     }
  12.     return
  13.   }
  14.   store._wrappedGetters[type] = function wrappedGetter (store) {
  15.     return rawGetter(
  16.       local.state, // local state
  17.       local.getters, // local getters
  18.       store.state, // root state
  19.       store.getters // root getters
  20.     )
  21.   }
  22. }

首先遍历模块中的 getters 的定义，拿到每一个 getter 和 key，并把 key 拼接上 namespace，然后执行 registerGetter 方法。该方法实际上就是给 root store 上的 _wrappedGetters[key] 指定 wrappedGetter 方法，该方法的具体实现我们之后会提到。注意，同一 type 的 _wrappedGetters 只能定义一个。

再回到 installModule 方法，最后一步就是遍历模块中的所有子 modules，递归执行 installModule 方法：

  1. module.forEachChild((child, key) => {
  2.   installModule(store, rootState, path.concat(key), child, hot)
  3. })

之前我们忽略了非 root module 下的 state 初始化逻辑，现在来看一下：

  1. if (!isRoot && !hot) {
  2.   const parentState = getNestedState(rootState, path.slice(0, -1))
  3.   const moduleName = path[path.length - 1]
  4.   store._withCommit(() => {
  5.     Vue.set(parentState, moduleName, module.state)
  6.   })
  7. }

之前我们提到过 getNestedState 方法，它是从 root state 开始，一层层根据模块名能访问到对应 path 的 state，那么它每一层关系的建立实际上就是通过这段 state 的初始化逻辑。store._withCommit 方法我们之后再介绍。

所以 installModule 实际上就是完成了模块下的 state、getters、actions、mutations 的初始化工作，并且通过递归遍历的方式，就完成了所有子模块的安装工作。

初始化 store._vm

Store 实例化的最后一步，就是执行初始化 store._vm 的逻辑，它的入口代码是：

  1. resetStoreVM(this, state)

来看一下 resetStoreVM 的定义：

  1. function resetStoreVM (store, state, hot) {
  2.   const oldVm = store._vm
  4.   // bind store public getters
  5.   store.getters = {}
  6.   const wrappedGetters = store._wrappedGetters
  7.   const computed = {}
  8.   forEachValue(wrappedGetters, (fn, key) => {
  9.     // use computed to leverage its lazy-caching mechanism
  10.     computed[key] = () => fn(store)
  11.     Object.defineProperty(store.getters, key, {
  12.       get: () => store._vm[key],
  13.       enumerable: true // for local getters
  14.     })
  15.   })
  17.   // use a Vue instance to store the state tree
  18.   // suppress warnings just in case the user has added
  19.   // some funky global mixins
  20.   const silent = Vue.config.silent
  21.   Vue.config.silent = true
  22.   store._vm = new Vue({
  23.     data: {
  24.       $$state: state
  25.     },
  26.     computed
  27.   })
  28.   Vue.config.silent = silent
  30.   // enable strict mode for new vm
  31.   if (store.strict) {
  32.     enableStrictMode(store)
  33.   }
  35.   if (oldVm) {
  36.     if (hot) {
  37.       // dispatch changes in all subscribed watchers
  38.       // to force getter re-evaluation for hot reloading.
  39.       store._withCommit(() => {
  40.         oldVm._data.$$state = null
  41.       })
  42.     }
  43.     Vue.nextTick(() => oldVm.$destroy())
  44.   }
  45. }

resetStoreVM 的作用实际上是想建立 getters 和 state 的联系，因为从设计上 getters 的获取就依赖了 state ，并且希望它的依赖能被缓存起来，且只有当它的依赖值发生了改变才会被重新计算。因此这里利用了 Vue 中用 computed 计算属性来实现。

resetStoreVM 首先遍历了 _wrappedGetters 获得每个 getter 的函数 fn 和 key，然后定义了 computed[key] = () => fn(store)。我们之前提到过 _wrappedGetters 的初始化过程，这里 fn(store) 相当于执行如下方法：

  1. store._wrappedGetters[type] = function wrappedGetter (store) {
  2.   return rawGetter(
  3.     local.state, // local state
  4.     local.getters, // local getters
  5.     store.state, // root state
  6.     store.getters // root getters
  7.   )
  8. }

返回的就是 rawGetter 的执行函数，rawGetter 就是用户定义的 getter 函数，它的前 2 个参数是 local state 和 local getters，后 2 个参数是 root state 和 root getters。

接着实例化一个 Vue 实例 store._vm，并把 computed 传入：

  1. store._vm = new Vue({
  2.   data: {
  3.     $$state: state
  4.   },
  5.   computed
  6. })

我们发现 data 选项里定义了 $$state 属性，而我们访问 store.state 的时候，实际上会访问 Store 类上定义的 state 的 get 方法：

  1. get state () {
  2.   return this._vm._data.$$state
  3. }

它实际上就访问了 store._vm._data.$$state。那么 getters 和 state 是如何建立依赖逻辑的呢，我们再看这段代码逻辑：

  1. forEachValue(wrappedGetters, (fn, key) => {
  2.     // use computed to leverage its lazy-caching mechanism
  3.     computed[key] = () => fn(store)
  4.     Object.defineProperty(store.getters, key, {
  5.       get: () => store._vm[key],
  6.       enumerable: true // for local getters
  7.     })
  8.   })

当我根据 key 访问 store.getters 的某一个 getter 的时候，实际上就是访问了 store._vm[key]，也就是 computed[key]，在执行 computed[key] 对应的函数的时候，会执行 rawGetter(local.state,...) 方法，那么就会访问到 store.state，进而访问到 store._vm._data.$$state，这样就建立了一个依赖关系。当 store.state 发生变化的时候，下一次再访问 store.getters 的时候会重新计算。

我们再来看一下 strict mode 的逻辑：

  1. if (store.strict) {
  2.   enableStrictMode(store)
  3. }
  5. function enableStrictMode (store) {
  6.   store._vm.$watch(function () { return this._data.$$state }, () => {
  7.     if (process.env.NODE_ENV !== 'production') {
  8.       assert(store._committing, `Do not mutate vuex store state outside mutation handlers.`)
  9.     }
  10.   }, { deep: true, sync: true })
  11. }

当严格模式下，store._vm 会添加一个 wathcer 来观测 this._data.$$state 的变化，也就是当 store.state 被修改的时候, store._committing 必须为 true，否则在开发阶段会报警告。store._committing 默认值是 false，那么它什么时候会 true 呢，Store 定义了 _withCommit 实例方法：

  1. _withCommit (fn) {
  2.   const committing = this._committing
  3.   this._committing = true
  4.   fn()
  5.   this._committing = committing
  6. }

它就是对 fn 包装了一个环境，确保在 fn 中执行任何逻辑的时候 this._committing = true。所以外部任何非通过 Vuex 提供的接口直接操作修改 state 的行为都会在开发阶段触发警告。

总结

那么至此，Vuex 的初始化过程就分析完毕了，除了安装部分，我们重点分析了 Store 的实例化过程。我们要把 store 想象成一个数据仓库，为了更方便的管理仓库，我们把一个大的 store 拆成一些 modules，整个 modules 是一个树型结构。每个 module 又分别定义了 state，getters，mutations、actions，我们也通过递归遍历模块的方式都完成了它们的初始化。为了 module 具有更高的封装度和复用性，还定义了 namespace 的概念。最后我们还定义了一个内部的 Vue 实例，用来建立 state 到 getters 的联系，并且可以在严格模式下监测 state 的变化是不是来自外部，确保改变 state 的唯一途径就是显式地提交 mutation。

这一节我们已经建立好 store，接下来就是对外提供了一些 API 方便我们对这个 store 做数据存取的操作，下一节我们就来从源码角度来分析 Vuex 提供的一系列 API。

API

上一节我们对 Vuex 的初始化过程有了深入的分析，在我们构造好这个 store 后，需要提供一些 API 对这个 store 做存取的操作，那么这一节我们就从源码的角度对这些 API 做分析。

数据获取

Vuex 最终存储的数据是在 state 上的，我们之前分析过在 store.state 存储的是 root state，那么对于模块上的 state，假设我们有 2 个嵌套的 modules，它们的 key 分别为 a 和 b，我们可以通过 store.state.a.b.xxx 的方式去获取。它的实现是在发生在 installModule 的时候：

  1. function installModule (store, rootState, path, module, hot) {
  2.   const isRoot = !path.length
  4.   // ...
  5.   // set state
  6.   if (!isRoot && !hot) {
  7.     const parentState = getNestedState(rootState, path.slice(0, -1))
  8.     const moduleName = path[path.length - 1]
  9.     store._withCommit(() => {
  10.       Vue.set(parentState, moduleName, module.state)
  11.     })
  12.   }
  13.   // ...
  14. }

在递归执行 installModule 的过程中，就完成了整个 state 的建设，这样我们就可以通过 module 名的 path 去访问到一个深层 module 的 state。

有些时候，我们获取的数据不仅仅是一个 state，而是由多个 state 计算而来，Vuex 提供了 getters，允许我们定义一个 getter 函数，如下：

  1. getters: {
  2.   total (state, getters, localState, localGetters) {
  3.     // 可访问全局 state 和 getters，以及如果是在 modules 下面，可以访问到局部 state 和 局部 getters
  4.     return state.a + state.b
  5.   }
  6. }

我们在 installModule 的过程中，递归执行了所有 getters 定义的注册，在之后的 resetStoreVM 过程中，执行了 store.getters 的初始化工作：

  1. function installModule (store, rootState, path, module, hot) {
  2.   // ...
  3.   const namespace = store._modules.getNamespace(path)
  4.   // ...
  5.   const local = module.context = makeLocalContext(store, namespace, path)
  7.   // ...
  9.   module.forEachGetter((getter, key) => {
  10.     const namespacedType = namespace + key
  11.     registerGetter(store, namespacedType, getter, local)
  12.   })
  14.   // ...
  15. }
  17. function registerGetter (store, type, rawGetter, local) {
  18.   if (store._wrappedGetters[type]) {
  19.     if (process.env.NODE_ENV !== 'production') {
  20.       console.error(`[vuex] duplicate getter key: ${type}`)
  21.     }
  22.     return
  23.   }
  24.   store._wrappedGetters[type] = function wrappedGetter (store) {
  25.     return rawGetter(
  26.       local.state, // local state
  27.       local.getters, // local getters
  28.       store.state, // root state
  29.       store.getters // root getters
  30.     )
  31.   }
  32. }
  35. function resetStoreVM (store, state, hot) {
  36.   // ...
  37.   // bind store public getters
  38.   store.getters = {}
  39.   const wrappedGetters = store._wrappedGetters
  40.   const computed = {}
  41.   forEachValue(wrappedGetters, (fn, key) => {
  42.     // use computed to leverage its lazy-caching mechanism
  43.     computed[key] = () => fn(store)
  44.     Object.defineProperty(store.getters, key, {
  45.       get: () => store._vm[key],
  46.       enumerable: true // for local getters
  47.     })
  48.   })
  50.   // use a Vue instance to store the state tree
  51.   // suppress warnings just in case the user has added
  52.   // some funky global mixins
  53.   // ...
  54.   store._vm = new Vue({
  55.     data: {
  56.       $$state: state
  57.     },
  58.     computed
  59.   })
  60.   // ...
  61. }

在 installModule 的过程中，为建立了每个模块的上下文环境，
因此当我们访问 store.getters.xxx 的时候，实际上就是执行了 rawGetter(local.state,...)，rawGetter 就是我们定义的 getter 方法，这也就是为什么我们的 getter 函数支持这四个参数，并且除了全局的 state 和 getter 外，我们还可以访问到当前 module 下的 state 和 getter。

数据存储

Vuex 对数据存储的存储本质上就是对 state 做修改，并且只允许我们通过提交 mutaion 的形式去修改 state，mutation 是一个函数，如下：

  1. mutations: {
  2.   increment (state) {
  3.     state.count++
  4.   }
  5. }

mutations 的初始化也是在 installModule 的时候：

  1. function installModule (store, rootState, path, module, hot) {
  2.   // ...
  3.   const namespace = store._modules.getNamespace(path)
  5.   // ...
  6.   const local = module.context = makeLocalContext(store, namespace, path)
  8.   module.forEachMutation((mutation, key) => {
  9.     const namespacedType = namespace + key
  10.     registerMutation(store, namespacedType, mutation, local)
  11.   })
  12.   // ...
  13. }
  15. function registerMutation (store, type, handler, local) {
  16.   const entry = store._mutations[type] || (store._mutations[type] = [])
  17.   entry.push(function wrappedMutationHandler (payload) {
  18.     handler.call(store, local.state, payload)
  19.   })
  20. }

store 提供了commit 方法让我们提交一个 mutation：

  1. commit (_type, _payload, _options) {
  2.   // check object-style commit
  3.   const {
  4.     type,
  5.     payload,
  6.     options
  7.   } = unifyObjectStyle(_type, _payload, _options)
  9.   const mutation = { type, payload }
  10.   const entry = this._mutations[type]
  11.   if (!entry) {
  12.     if (process.env.NODE_ENV !== 'production') {
  13.       console.error(`[vuex] unknown mutation type: ${type}`)
  14.     }
  15.     return
  16.   }
  17.   this._withCommit(() => {
  18.     entry.forEach(function commitIterator (handler) {
  19.       handler(payload)
  20.     })
  21.   })
  22.   this._subscribers.forEach(sub => sub(mutation, this.state))
  24.   if (
  25.     process.env.NODE_ENV !== 'production' &&
  26.     options && options.silent
  27.   ) {
  28.     console.warn(
  29.       `[vuex] mutation type: ${type}. Silent option has been removed. ` +
  30.       'Use the filter functionality in the vue-devtools'
  31.     )
  32.   }
  33. }

这里传入的 _type 就是 mutation 的 type，我们可以从 store._mutations 找到对应的函数数组，遍历它们执行获取到每个 handler 然后执行，实际上就是执行了 wrappedMutationHandler(playload)，接着会执行我们定义的 mutation 函数，并传入当前模块的 state，所以我们的 mutation 函数也就是对当前模块的 state 做修改。

需要注意的是， mutation 必须是同步函数，但是我们在开发实际项目中，经常会遇到要先去发送一个请求，然后根据请求的结果去修改 state，那么单纯只通过 mutation 是无法完成需求，因此 Vuex 又给我们设计了一个 action 的概念。

action 类似于 mutation，不同在于 action 提交的是 mutation，而不是直接操作 state，并且它可以包含任意异步操作。例如：

  1. mutations: {
  2.   increment (state) {
  3.     state.count++
  4.   }
  5. },
  6. actions: {
  7.   increment (context) {
  8.     setTimeout(() => {
  9.       context.commit('increment')
  10.     }, 0)
  11.   }
  12. }

actions 的初始化也是在 installModule 的时候：

  1. function installModule (store, rootState, path, module, hot) {
  2.   // ...
  3.   const namespace = store._modules.getNamespace(path)
  5.   // ...
  6.   const local = module.context = makeLocalContext(store, namespace, path)
  8.   module.forEachAction((action, key) => {
  9.     const type = action.root ? key : namespace + key
  10.     const handler = action.handler || action
  11.     registerAction(store, type, handler, local)
  12. }  )
  13.   // ...
  14. }
  16. function registerAction (store, type, handler, local) {
  17.   const entry = store._actions[type] || (store._actions[type] = [])
  18.   entry.push(function wrappedActionHandler (payload, cb) {
  19.     let res = handler.call(store, {
  20.       dispatch: local.dispatch,
  21.       commit: local.commit,
  22.       getters: local.getters,
  23.       state: local.state,
  24.       rootGetters: store.getters,
  25.       rootState: store.state
  26.     }, payload, cb)
  27.     if (!isPromise(res)) {
  28.       res = Promise.resolve(res)
  29.     }
  30.     if (store._devtoolHook) {
  31.       return res.catch(err => {
  32.         store._devtoolHook.emit('vuex:error', err)
  33.         throw err
  34.       })
  35.     } else {
  36.       return res
  37.     }
  38.   })
  39. }

store 提供了dispatch 方法让我们提交一个 action：

  1. dispatch (_type, _payload) {
  2.   // check object-style dispatch
  3.   const {
  4.     type,
  5.     payload
  6.   } = unifyObjectStyle(_type, _payload)
  8.   const action = { type, payload }
  9.   const entry = this._actions[type]
  10.   if (!entry) {
  11.     if (process.env.NODE_ENV !== 'production') {
  12.       console.error(`[vuex] unknown action type: ${type}`)
  13.     }
  14.     return
  15.   }
  17.   this._actionSubscribers.forEach(sub => sub(action, this.state))
  19.   return entry.length > 1
  20.     ? Promise.all(entry.map(handler => handler(payload)))
  21.     : entry[0](payload)
  22. }

这里传入的 _type 就是 action 的 type，我们可以从 store._actions 找到对应的函数数组，遍历它们执行获取到每个 handler 然后执行，实际上就是执行了 wrappedActionHandler(payload)，接着会执行我们定义的 action 函数，并传入一个对象，包含了当前模块下的 dispatch、commit、getters、state，以及全局的 rootState 和 rootGetters，所以我们定义的 action 函数能拿到当前模块下的 commit 方法。

因此 action 比我们自己写一个函数执行异步操作然后提交 muataion 的好处是在于它可以在参数中获取到当前模块的一些方法和状态，Vuex 帮我们做好了这些。

语法糖

我们知道 store 是 Store 对象的一个实例，它是一个原生的 Javascript 对象，我们可以在任意地方使用它们。但大部分的使用场景还是在组件中使用，那么我们之前介绍过，在 Vuex 安装阶段，它会往每一个组件实例上混入 beforeCreate 钩子函数，然后往组件实例上添加一个 $store 的实例，它指向的就是我们实例化的 store，因此我们可以在组件中访问到 store 的任何属性和方法。

比如我们在组件中访问 state：

  1. const Counter = {
  2.   template: `<div>{{ count }}</div>`,
  3.   computed: {
  4.     count () {
  5.       return this.$store.state.count
  6.     }
  7.   }
  8. }

但是当一个组件需要获取多个状态时候，将这些状态都声明为计算属性会有些重复和冗余。同样这些问题也在存于 getter、mutation 和 action。

为了解决这个问题，Vuex 提供了一系列 mapXXX 辅助函数帮助我们实现在组件中可以很方便的注入 store 的属性和方法。

mapState

我们先来看一下 mapState 的用法：

  1. // 在单独构建的版本中辅助函数为 Vuex.mapState
  2. import { mapState } from 'vuex'
  4. export default {
  5.   // ...
  6.   computed: mapState({
  7.     // 箭头函数可使代码更简练
  8.     count: state => state.count,
  10.     // 传字符串参数 'count' 等同于 `state => state.count`
  11.     countAlias: 'count',
  13.     // 为了能够使用 `this` 获取局部状态，必须使用常规函数
  14.     countPlusLocalState (state) {
  15.       return state.count + this.localCount
  16.     }
  17.   })
  18. }

再来看一下 mapState 方法的定义，在 src/helpers.js 中：

  1. export const mapState = normalizeNamespace((namespace, states) => {
  2.   const res = {}
  3.   normalizeMap(states).forEach(({ key, val }) => {
  4.     res[key] = function mappedState () {
  5.       let state = this.$store.state
  6.       let getters = this.$store.getters
  7.       if (namespace) {
  8.         const module = getModuleByNamespace(this.$store, 'mapState', namespace)
  9.         if (!module) {
  10.           return
  11.         }
  12.         state = module.context.state
  13.         getters = module.context.getters
  14.       }
  15.       return typeof val === 'function'
  16.         ? val.call(this, state, getters)
  17.         : state[val]
  18.     }
  19.     // mark vuex getter for devtools
  20.     res[key].vuex = true
  21.   })
  22.   return res
  23. })
  25. function normalizeNamespace (fn) {
  26.   return (namespace, map) => {
  27.     if (typeof namespace !== 'string') {
  28.       map = namespace
  29.       namespace = ''
  30.     } else if (namespace.charAt(namespace.length - 1) !== '/') {
  31.       namespace += '/'
  32.     }
  33.     return fn(namespace, map)
  34.   }
  35. }
  37. function normalizeMap (map) {
  38.   return Array.isArray(map)
  39.     ? map.map(key => ({ key, val: key }))
  40.     : Object.keys(map).map(key => ({ key, val: map[key] }))
  41. }

首先 mapState 是通过执行 normalizeNamespace 返回的函数，它接收 2 个参数，其中 namespace 表示命名空间，map 表示具体的对象，namespace 可不传，稍后我们来介绍 namespace 的作用。

当执行 mapState(map) 函数的时候，实际上就是执行 normalizeNamespace 包裹的函数，然后把 map 作为参数 states 传入。

mapState 最终是要构造一个对象，每个对象的元素都是一个方法，因为这个对象是要扩展到组件的 computed 计算属性中的。函数首先执行 normalizeMap 方法，把这个 states 变成一个数组，数组的每个元素都是 {key, val} 的形式。接着再遍历这个数组，以 key 作为对象的 key，值为一个 mappedState 的函数，在这个函数的内部，获取到 $store.getters 和 $store.state，然后再判断数组的 val 如果是一个函数，执行该函数，传入 state 和 getters，否则直接访问 state[val]。

比起一个个手动声明计算属性，mapState 确实要方便许多，下面我们来看一下 namespace 的作用。

当我们想访问一个子模块的 state 的时候，我们可能需要这样访问：

  1. computed: {
  2.   mapState({
  3.     a: state => state.some.nested.module.a,
  4.     b: state => state.some.nested.module.b
  5.   })
  6. },

这样从写法上就很不友好，mapState 支持传入 namespace， 因此我们可以这么写：

  1. computed: {
  2.   mapState('some/nested/module', {
  3.     a: state => state.a,
  4.     b: state => state.b
  5.   })
  6. },

这样看起来就清爽许多。在 mapState 的实现中，如果有 namespace，则尝试去通过 getModuleByNamespace(this.$store, 'mapState', namespace) 对应的 module，然后把 state 和 getters 修改为 module 对应的 state 和 getters。

  1. function getModuleByNamespace (store, helper, namespace) {
  2.   const module = store._modulesNamespaceMap[namespace]
  3.   if (process.env.NODE_ENV !== 'production' && !module) {
  4.     console.error(`[vuex] module namespace not found in ${helper}(): ${namespace}`)
  5.   }
  6.   return module
  7. }

我们在 Vuex 初始化执行 installModule 的过程中，初始化了这个映射表：

  1. function installModule (store, rootState, path, module, hot) {
  2.   // ...
  3.   const namespace = store._modules.getNamespace(path)
  5.   // register in namespace map
  6.   if (module.namespaced) {
  7.     store._modulesNamespaceMap[namespace] = module
  8.   }
  10.   // ...
  11. }

mapGetters

我们先来看一下 mapGetters 的用法：

  1. import { mapGetters } from 'vuex'
  3. export default {
  4.   // ...
  5.   computed: {
  6.     // 使用对象展开运算符将 getter 混入 computed 对象中
  7.     mapGetters([
  8.       'doneTodosCount',
  9.       'anotherGetter',
  10.       // ...
  11.     ])
  12.   }
  13. }

和 mapState 类似，mapGetters 是将 store 中的 getter 映射到局部计算属性，来看一下它的定义：

  1. export const mapGetters = normalizeNamespace((namespace, getters) => {
  2.   const res = {}
  3.   normalizeMap(getters).forEach(({ key, val }) => {
  4.     // thie namespace has been mutate by normalizeNamespace
  5.     val = namespace + val
  6.     res[key] = function mappedGetter () {
  7.       if (namespace && !getModuleByNamespace(this.$store, 'mapGetters', namespace)) {
  8.         return
  9.       }
  10.       if (process.env.NODE_ENV !== 'production' && !(val in this.$store.getters)) {
  11.         console.error(`[vuex] unknown getter: ${val}`)
  12.         return
  13.       }
  14.       return this.$store.getters[val]
  15.     }
  16.     // mark vuex getter for devtools
  17.     res[key].vuex = true
  18.   })
  19.   return res
  20. })

mapGetters 也同样支持 namespace，如果不写 namespace ，访问一个子 module 的属性需要写很长的 key，一旦我们使用了 namespace，就可以方便我们的书写，每个 mappedGetter 的实现实际上就是取 this.$store.getters[val]。

mapMutations

我们可以在组件中使用 this.$store.commit('xxx') 提交 mutation，或者使用 mapMutations 辅助函数将组件中的 methods 映射为 store.commit 的调用。

我们先来看一下 mapMutations 的用法：

  1. import { mapMutations } from 'vuex'
  3. export default {
  4.   // ...
  5.   methods: {
  6.     ...mapMutations([
  7.       'increment', // 将 `this.increment()` 映射为 `this.$store.commit('increment')`
  9.       // `mapMutations` 也支持载荷：
  10.       'incrementBy' // 将 `this.incrementBy(amount)` 映射为 `this.$store.commit('incrementBy', amount)`
  11.     ]),
  12.     ...mapMutations({
  13.       add: 'increment' // 将 `this.add()` 映射为 `this.$store.commit('increment')`
  14.     })
  15.   }
  16. }

mapMutations 支持传入一个数组或者一个对象，目标都是组件中对应的 methods 映射为 store.commit 的调用。来看一下它的定义：

  1. export const mapMutations = normalizeNamespace((namespace, mutations) => {
  2.   const res = {}
  3.   normalizeMap(mutations).forEach(({ key, val }) => {
  4.     res[key] = function mappedMutation (...args) {
  5.       // Get the commit method from store
  6.       let commit = this.$store.commit
  7.       if (namespace) {
  8.         const module = getModuleByNamespace(this.$store, 'mapMutations', namespace)
  9.         if (!module) {
  10.           return
  11.         }
  12.         commit = module.context.commit
  13.       }
  14.       return typeof val === 'function'
  15.         ? val.apply(this, [commit].concat(args))
  16.         : commit.apply(this.$store, [val].concat(args))
  17.     }
  18.   })
  19.   return res
  20. })

可以看到 mappedMutation 同样支持了 namespace，并且支持了传入额外的参数 args，作为提交 mutation 的 payload，最终就是执行了 store.commit 方法，并且这个 commit 会根据传入的 namespace 映射到对应 module 的 commit 上。

mapActions

我们可以在组件中使用 this.$store.dispatch('xxx') 提交 action，或者使用 mapActions 辅助函数将组件中的 methods 映射为 store.dispatch 的调用。

mapActions 在用法上和 mapMutations 几乎一样，实现也很类似：

  1. export const mapActions = normalizeNamespace((namespace, actions) => {
  2.   const res = {}
  3.   normalizeMap(actions).forEach(({ key, val }) => {
  4.     res[key] = function mappedAction (...args) {
  5.       // get dispatch function from store
  6.       let dispatch = this.$store.dispatch
  7.       if (namespace) {
  8.         const module = getModuleByNamespace(this.$store, 'mapActions', namespace)
  9.         if (!module) {
  10.           return
  11.         }
  12.         dispatch = module.context.dispatch
  13.       }
  14.       return typeof val === 'function'
  15.         ? val.apply(this, [dispatch].concat(args))
  16.         : dispatch.apply(this.$store, [val].concat(args))
  17.     }
  18.   })
  19.   return res
  20. })

和 mapMutations 的实现几乎一样，不同的是把 commit 方法换成了 dispatch。

动态更新模块

在 Vuex 初始化阶段我们构造了模块树，初始化了模块上各个部分。在有一些场景下，我们需要动态去注入一些新的模块，Vuex 提供了模块动态注册功能，在 store 上提供了一个 registerModule 的 API。

  1. registerModule (path, rawModule, options = {}) {
  2.   if (typeof path === 'string') path = [path]
  4.   if (process.env.NODE_ENV !== 'production') {
  5.     assert(Array.isArray(path), `module path must be a string or an Array.`)
  6.     assert(path.length > 0, 'cannot register the root module by using registerModule.')
  7.   }
  9.   this._modules.register(path, rawModule)
  10.   installModule(this, this.state, path, this._modules.get(path), options.preserveState)
  11.   // reset store to update getters...
  12.   resetStoreVM(this, this.state)
  13. }

registerModule 支持传入一个 path 模块路径 和 rawModule 模块定义，首先执行 register 方法扩展我们的模块树，接着执行 installModule 去安装模块，最后执行 resetStoreVM 重新实例化 store._vm，并销毁旧的 store._vm。

相对的，有动态注册模块的需求就有动态卸载模块的需求，Vuex 提供了模块动态卸载功能，在 store 上提供了一个 unregisterModule 的 API。

  1. unregisterModule (path) {
  2.   if (typeof path === 'string') path = [path]
  4.   if (process.env.NODE_ENV !== 'production') {
  5.     assert(Array.isArray(path), `module path must be a string or an Array.`)
  6.   }
  8.   this._modules.unregister(path)
  9.   this._withCommit(() => {
  10.     const parentState = getNestedState(this.state, path.slice(0, -1))
  11.     Vue.delete(parentState, path[path.length - 1])
  12.   })
  13.   resetStore(this)
  14. }

unregisterModule 支持传入一个 path 模块路径，首先执行 unregister 方法去修剪我们的模块树：

  1. unregister (path) {
  2.   const parent = this.get(path.slice(0, -1))
  3.   const key = path[path.length - 1]
  4.   if (!parent.getChild(key).runtime) return
  6.   parent.removeChild(key)
  7. }

注意，这里只会移除我们运行时动态创建的模块。

接着会删除 state 在该路径下的引用，最后执行 resetStore 方法：

  1. function resetStore (store, hot) {
  2.   store._actions = Object.create(null)
  3.   store._mutations = Object.create(null)
  4.   store._wrappedGetters = Object.create(null)
  5.   store._modulesNamespaceMap = Object.create(null)
  6.   const state = store.state
  7.   // init all modules
  8.   installModule(store, state, [], store._modules.root, true)
  9.   // reset vm
  10.   resetStoreVM(store, state, hot)
  11. }

该方法就是把 store 下的对应存储的 _actions、_mutations、_wrappedGetters 和 _modulesNamespaceMap 都清空，然后重新执行 installModule 安装所有模块以及 resetStoreVM 重置 store._vm。

总结

那么至此，Vuex 提供的一些常用 API 我们就分析完了，包括数据的存取、语法糖、模块的动态更新等。要理解 Vuex 提供这些 API 都是方便我们在对 store 做各种操作来完成各种能力，尤其是 mapXXX 的设计，让我们在使用 API 的时候更加方便，这也是我们今后在设计一些 JavaScript 库的时候，从 API 设计角度中应该学习的方向。