文章目录

Vuex详解
回顾

Vuex详解

认识Vuex

Vuex是做什么的？

官方解释：Vuex是一个专为Vue.js应用程序开发的状态管理模式。
- 它采用集中式存储管理应用的所有组件的状态，并以相应的规则保证状态以一种可预测的方式发生变化。
- Vuex也集成到Vue的官方调试工具devtools extension，提供了诸如零配置的time-travel调试、状态快照导入导出等道济调试功能。
状态管理到底是什么？
- 状态管理模式、集中式存储管理这些名词听起来就就非常高大上，让人捉摸不透。
- 其实，你可以简单的将其看成把需要多个组件共享的变量全部存储在一个对象里面。
- 然后，将这个对象放在顶层的Vue实例中，让其他组件可以使用。
- 那么，多个组件是不是就可以共享这个对象中的所有变量属性了呢？
等等，如果是这样的话，为什么官方还要专门出一个插件Vuex呢？难道我们不能自己封装一个对象来管理么？
- 当然可以，只是我们要先详细那个Vuejs带给我们最大的便利是什么呢？没错，就是响应式。
- 如果你自己封装实现一个对象能不能保证它里面所有的属性做到响应式呢？当然也可以，只是自己封装可能稍微麻烦一些。
- 不用怀疑，Vuex就是为了提供这样一个在多个组件间共享状态的插件，用它就可以了。

管理什么状态呢？

但是，有什么状态需要我们在多个组件间共享呢？
- 如果你做过大型开发，你一定遇到过多个状态，在多个界面间的共享问题。
- 比如用户的登录状态、用户名称、头像、地理位置信息等等。
- 比如用户的收藏、购物车中的物品等等。
- 这些信息，我们都可以放在同一的地方，对它进行保存和管理，而且他们还是响应式的。
Ok，从理论上理解了状态管理之后，让我们从实际代码来看看状态管理。

单页面的状态管理

我们知道，要在单个组件中进行状态管理是一件非常简单的事情。
- 什么意思呢？我们来看下面的图片。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PR1SgHye-1610624245020)(/Users/mac/Desktop/前端学习笔记/vue/vue笔记十三/1.png)]

这图片中的三种东西，怎么理解呢？
- State：不同多说，这就是我们的状态。（姑且可以当做就是data中的属性）
- View：视图层，可以针对State的变化，显示不同的信息。
- Actions：这里的Actions主要是用户的各种操作：点击、输入等等，会导致状态的变化。
写点代码加深理解吧：

<template>
  <div id="app">
    <h2>{
    
    {
    
    message}}</h2>
    <h2>{
    
    {
    
    counter}}</h2>
    <button @click="counter++">+</button>
    <button @click="counter--">-</button>
  </div>
</template>

<script>

export default {
    
    
  name: 'App',
  components: {
    
    
  },
  data() {
    
    
    return {
    
    
      message: '我是App组件',
      counter: 0
    }
  }
}
</script>

<style>
</style>

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5myL8w4M-1610624245022)(/Users/mac/Desktop/前端学习笔记/vue/vue笔记十三/2.gif)]

在这个案例中，我们有没有状态需要管理呢？没错，就是个数counter。
counter需要某种方式被记录下来，也就是我们的State。
counter目前的值需要被现实在界面中，也就是我们的View部分。
界面发生某些操作时（我们这里是用户的点击，也可以是用户的input），需要去更新状态，也就是我们的Actions。
这不就是上面的流程图了么？

多界面状态管理

Vue已经帮我们做好了单个界面的状态管理，但是如果是多个界面呢？
- 多个界面都依赖同一个状态（一个状态改了，多个界面需要进行更新）
- 不同界面的Actions都想修改同一个状态（Home.vue需要修改，Profile.vue也需要修改这个状态）
也就是说对于某些状态（状态1/状态2/状态3）来说只属于我们一个界面，但是也有一些状态（状态a/状态b/状态c）属于多个页面共同想要维护的。
- 状态1/状态2/状态3你自己放在自己的房间里，你自己管理自己用，没问题。
- 但是状态a/状态b/状态c我们希望交给一个大管家统一帮助我们管理。
- 没错，Vuex就是为我们提供这个大管家的工具。
全局单例模式（大管家）
- 我们现在要做的就是将共享的状态抽取出来，交给我们的大管家，统一进行管理。
- 之后，你们每个界面，按照我规定好的规定，进行访问和修改等操作。
- 这就是Vuex背后的思想。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oJ4VkeYZ-1610624245027)(/Users/mac/Desktop/前端学习笔记/vue/vue笔记十三/3.png)]

devtool插件

Vue为我们提供了浏览器的跟踪插件，可以帮助我们跟踪通过mutation修改的状态。
我们在google的应用商城里面搜devtools，并安装这个插件：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sgfP805L-1610624245032)(/Users/mac/Desktop/前端学习笔记/vue/vue笔记十三/4.jpg)]

此时我们就可以使用这个插件来跟踪我们的状态了。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SPyObSEY-1610624245038)(/Users/mac/Desktop/前端学习笔记/vue/vue笔记十三/5.jpg)]

Vuex的简单使用

首先，我们需要在某个地方存放我们的Vuex代码：
- 先创建一个store文件夹，并且在其中创建一个index.js文件。
- 在index.js文件中写入如下代码：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hNDdK9eW-1610624245051)(/Users/mac/Desktop/前端学习笔记/vue/vue笔记十三/6.jpg)]

在main.js中导入store对象：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9LKBrfRA-1610624245055)(/Users/mac/Desktop/前端学习笔记/vue/vue笔记十三/7.jpg)]

在App.vue中：

<template>
  <div id="app">
    <h2>App内容：</h2>
    <h2>{
    
    {
    
    $store.state.counter}}</h2>
    <button @click="addition">+</button>
    <button @click="subtrction">-</button>

    <h2>Vuex内容：</h2>
    <hello-vuex></hello-vuex>
  </div>
</template>

<script>
import HelloVuex from './components/HelloVuex'

export default {
    
    
  name: 'App',
  components: {
    
    
    HelloVuex
  },
  data() {
    
    
    return {
    
    
      message: '我是App组件',
    }
  },
  methods: {
    
    
    addition() {
    
    
      this.$store.commit('increment')
    },
    subtrction() {
    
    
      this.$store.commit('decrement')
    }
  }
}
</script>

<style>
</style>

效果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4cWpjnDi-1610624245056)(/Users/mac/Desktop/前端学习笔记/vue/vue笔记十三/8.gif)]

总结：
- 提取出一个公共的store对象，用于保存在多个组件中共享的状态。
- 将store对象放置在new Vue对象中，这样可以保证在所有组件中都可以使用到。
- 在其他组件中使用store对象中保存的状态即可：
  - 通过this.$store.state属性的方式来访问状态。
  - 通过this.$store.commit('mutation中方法')来修改状态。
注意事项：
- 我们通过提交mutation的方式，而非直接改变store.state.counter。
- 这是因为Vuex可以更明确的追踪状态的变化，所以不要直接台变store.state.counter的值。

Vuex核心概念（官方）

Vuex有几个比较核心的概念：
- State
- Getters
- Mutation
- Action
- Module

State单一状态树

Vuex提出单一状态树，什么是单一状态树呢？
- 英文名称是Single Source of Truth，也可以翻译成单一数据源。
但是，它是什么呢？我们来看一个例子。
- 我们知道，在国内我们有很多的信息需要被记录，比如上学时的个人档案，工作后的社保记录，公积金记录，结婚后的婚姻信息，以及其他相关的户口、医疗、文凭、房产记录等等。
- 这些信息被分散在很多地方进行管理，有一天，你需要办某个业务时（比如入户某个城市），你会发现你需要到各个对应的工作地点去打印、盖章各种资料信息，最后到一个地方提交证明你的信息无误。
- 这种保存信息的方案，不仅仅低效，而且不方便管理，以及日后的维护也是一个庞大的工作（需要大量的各个部门的人力来维护，当然国家目前已经在完善我们这个系统了）。
这个和我们开发中比较类似：
- 如果你的状态信息是保存到多个Store对象中，那么之后的管理和维护等等会变得特别困难。
- 所以Vuex也是用了单一状态树来管理应用层级的全部状态。
- 单一状态树能够让我们最直接的方式找到某个状态的片段，而且在之后的维护和调试过程中，也可以非常方便的管理和维护了。

Getters基本使用

通过属性访问

有时候，我们需要从store中获取一些state变化后的状态，比如我们想将counter做一个平方：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jqC06EJD-1610624245058)(/Users/mac/Desktop/前端学习笔记/vue/vue笔记十三/9.jpg)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-57xFzkcl-1610624245062)(/Users/mac/Desktop/前端学习笔记/vue/vue笔记十三/10.jpg)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qZUnMdCC-1610624245064)(/Users/mac/Desktop/前端学习笔记/vue/vue笔记十三/11.jpg)]

通过方法访问

你也可以通过让 getter 返回一个函数，来实现给 getter 传参。在你对 store 里的数组进行查询时非常有用。

getters: {
    
    
  // ...
  getTodoById: (state) => (id) => {
    
    
    return state.todos.find(todo => todo.id === id)
  }
}
store.getters.getTodoById(2) // -> { id: 2, text: '...', done: false }

注意，getter 在通过方法访问时，每次都会去进行调用，而不会缓存结果。

Mutation

Mutation状态更新

Vuex的store状态的更新唯一方式：提交Mutation。
Mutation主要包括两部分：
- 字符串的事件类型(type)
- 一个回调函数(handler)，该回调函数的第一个参数就是state。
mutation的定义方式：

mutations: {
    
    
	increment(state) {
    
    
		state.counter++
	}
}

通过mutation更新：

increment: function() {
    
    
	this.$store.commit('increment')
}

Mutation传递参数

在通过mutation更新数据的时候，有可能我们希望携带一些额外的参数。
- 参数被称为是mutation的载荷（Payload）
mutation中的代码：

decrement(state, n) {
    
    
	state.count -= n
}

----------

decrement: function() {
    
    
	this.$store.commit('decrement', 2)
}

但是如果参数不是一个呢？
- 比如我们有很多参数需要传递。
- 这个时候，我们通常会以对象的形式传递，也就是payload是一个对象。
- 这个时候可以再从对象中取出相关的信息。

Mutation提交风格

提交 mutation 的另一种方式是直接使用包含 type 属性的对象：

store.commit({
    
    
  type: 'increment',
  amount: 10
})

当使用对象风格的提交方式，整个对象都作为载荷传给 mutation 函数，因此 handler 保持不变：

mutations: {
    
    
  increment (state, payload) {
    
    
    state.count += payload.amount
  }
}

Mutation需遵守 Vue 的响应规则

既然 Vuex 的 store 中的状态是响应式的，那么当我们变更状态时，监视状态的 Vue 组件也会自动更新。这也意味着 Vuex 中的 mutation 也需要与使用 Vue 一样遵守一些注意事项：

最好提前在你的 store 中初始化好所有所需属性。
当需要在对象上添加新属性时，你应该

使用 Vue.set(obj, 'newProp', 123), 或者
以新对象替换老对象。例如，利用对象展开运算符 (opens new window)我们可以这样写：
```
state.obj = {
      
       ...state.obj, newProp: 123 }
```
同理，使用Vue.delete()删除属性。

Mutation常量类型

使用常量替代 mutation 事件类型在各种 Flux 实现中是很常见的模式。这样可以使 linter 之类的工具发挥作用，同时把这些常量放在单独的文件中可以让你的代码合作者对整个 app 包含的 mutation 一目了然：

// mutation-types.js
export const SOME_MUTATION = 'SOME_MUTATION'
// store.js
import Vuex from 'vuex'
import {
    
     SOME_MUTATION } from './mutation-types'

const store = new Vuex.Store({
    
    
  state: {
    
     ... },
  mutations: {
    
    
    // 我们可以使用 ES2015 风格的计算属性命名功能来使用一个常量作为函数名
    [SOME_MUTATION] (state) {
    
    
      // mutate state
    }
  }
})

用不用常量取决于你——在需要多人协作的大型项目中，这会很有帮助。但如果你不喜欢，你完全可以不这样做。

Mutation同步函数

一条重要的原则就是要记住 mutation 必须是同步函数。为什么？请参考下面的例子：

mutations: {
    
    
  someMutation (state) {
    
    
    api.callAsyncMethod(() => {
    
    
      state.count++
    })
  }
}

现在想象，我们正在 debug 一个 app 并且观察 devtool 中的 mutation 日志。
每一条 mutation 被记录，devtools 都需要捕捉到前一状态和后一状态的快照。
然而，在上面的例子中 mutation 中的异步函数中的回调让这不可能完成：因为当 mutation 触发的时候，回调函数还没有被调用，devtools 不知道什么时候回调函数实际上被调用——实质上任何在回调函数中进行的状态的改变都是不可追踪的。

Action的基本定义

我们强调，不要在Mutation中进行异步操作：
- 但某些情况，我们确实希望在Vuex中进行一些异步操作，比如网络请求，必然是异步的，这个时候怎么处理呢？
- Action类似于Mutation，但是用来代替Mutation进行异步操作。

Action 类似于 mutation，不同在于：

Action 提交的是 mutation，而不是直接变更状态。
Action 可以包含任意异步操作。

让我们来注册一个简单的 action：

const store = new Vuex.Store({
    
    
  state: {
    
    
    count: 0
  },
  mutations: {
    
    
    increment (state) {
    
    
      state.count++
    }
  },
  actions: {
    
    
    increment (context) {
    
    
      context.commit('increment')
    }
  }
})

Action 函数接受一个与 store 实例具有相同方法和属性的 context 对象，因此你可以调用 context.commit 提交一个 mutation，或者通过 context.state 和 context.getters 来获取 state 和 getters。当我们在之后介绍到 Modules 时，你就知道 context 对象为什么不是 store 实例本身了。

实践中，我们会经常用到 ES2015 的参数解构 (opens new window)来简化代码（特别是我们需要调用 commit 很多次的时候）：

actions: {
    
    
  increment ({
    
     commit }) {
    
    
    commit('increment')
  }
}

分发Action

Action 通过 store.dispatch 方法触发：

store.dispatch('increment')

乍一眼看上去感觉多此一举，我们直接分发 mutation 岂不更方便？实际上并非如此，还记得 mutation 必须同步执行这个限制么？Action 就不受约束！我们可以在 action 内部执行异步操作：

actions: {
    
    
  incrementAsync ({
    
     commit }) {
    
    
    setTimeout(() => {
    
    
      commit('increment')
    }, 1000)
  }
}

Actions 支持同样的载荷方式和对象方式进行分发：

// 以载荷形式分发
store.dispatch('incrementAsync', {
    
    
  amount: 10
})

// 以对象形式分发
store.dispatch({
    
    
  type: 'incrementAsync',
  amount: 10
})

来看一个更加实际的购物车示例，涉及到调用异步 API 和分发多重 mutation：

actions: {
    
    
  checkout ({
    
     commit, state }, products) {
    
    
    // 把当前购物车的物品备份起来
    const savedCartItems = [...state.cart.added]
    // 发出结账请求，然后乐观地清空购物车
    commit(types.CHECKOUT_REQUEST)
    // 购物 API 接受一个成功回调和一个失败回调
    shop.buyProducts(
      products,
      // 成功操作
      () => commit(types.CHECKOUT_SUCCESS),
      // 失败操作
      () => commit(types.CHECKOUT_FAILURE, savedCartItems)
    )
  }
}

注意我们正在进行一系列的异步操作，并且通过提交 mutation 来记录 action 产生的副作用（即状态变更）。

在组件中分发 Action

你在组件中使用 this.$store.dispatch('xxx') 分发 action，或者使用 mapActions 辅助函数将组件的 methods 映射为 store.dispatch 调用（需要先在根节点注入 store）：

import {
    
     mapActions } from 'vuex'

export default {
    
    
  // ...
  methods: {
    
    
    ...mapActions([
      'increment', // 将 `this.increment()` 映射为 `this.$store.dispatch('increment')`

      // `mapActions` 也支持载荷：
      'incrementBy' // 将 `this.incrementBy(amount)` 映射为 `this.$store.dispatch('incrementBy', amount)`
    ]),
    ...mapActions({
    
    
      add: 'increment' // 将 `this.add()` 映射为 `this.$store.dispatch('increment')`
    })
  }
}

组合 Action

Action 通常是异步的，那么如何知道 action 什么时候结束呢？更重要的是，我们如何才能组合多个 action，以处理更加复杂的异步流程？

首先，你需要明白 store.dispatch 可以处理被触发的 action 的处理函数返回的 Promise，并且 store.dispatch 仍旧返回 Promise：

actions: {
    
    
  actionA ({
    
     commit }) {
    
    
    return new Promise((resolve, reject) => {
    
    
      setTimeout(() => {
    
    
        commit('someMutation')
        resolve()
      }, 1000)
    })
  }
}

现在你可以：

store.dispatch('actionA').then(() => {
    
    
  // ...
})

在另外一个 action 中也可以：

actions: {
    
    
  // ...
  actionB ({
    
     dispatch, commit }) {
    
    
    return dispatch('actionA').then(() => {
    
    
      commit('someOtherMutation')
    })
  }
}

最后，如果我们利用 async / await (opens new window)，我们可以如下组合 action：

// 假设 getData() 和 getOtherData() 返回的是 Promise

actions: {
    
    
  async actionA ({
    
     commit }) {
    
    
    commit('gotData', await getData())
  },
  async actionB ({
    
     dispatch, commit }) {
    
    
    await dispatch('actionA') // 等待 actionA 完成
    commit('gotOtherData', await getOtherData())
  }
}

一个 store.dispatch 在不同模块中可以触发多个 action 函数。在这种情况下，只有当所有触发函数完成后，返回的 Promise 才会执行。

Modules

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

const moduleA = {
    
    
  state: () => ({
    
     ... }),
  mutations: {
    
     ... },
  actions: {
    
     ... },
  getters: {
    
     ... }
}

const moduleB = {
    
    
  state: () => ({
    
     ... }),
  mutations: {
    
     ... },
  actions: {
    
     ... }
}

const store = new Vuex.Store({
    
    
  modules: {
    
    
    a: moduleA,
    b: moduleB
  }
})

store.state.a // -> moduleA 的状态
store.state.b // -> moduleB 的状态

模块的局部状态

对于模块内部的 mutation 和 getter，接收的第一个参数是模块的局部状态对象。

const moduleA = {
    
    
  state: () => ({
    
    
    count: 0
  }),
  mutations: {
    
    
    increment (state) {
    
    
      // 这里的 `state` 对象是模块的局部状态
      state.count++
    }
  },

  getters: {
    
    
    doubleCount (state) {
    
    
      return state.count * 2
    }
  }
}

同样，对于模块内部的 action，局部状态通过 context.state 暴露出来，根节点状态则为 context.rootState：

const moduleA = {
    
    
  // ...
  actions: {
    
    
    incrementIfOddOnRootSum ({
    
     state, commit, rootState }) {
    
    
      if ((state.count + rootState.count) % 2 === 1) {
    
    
        commit('increment')
      }
    }
  }
}

对于模块内部的 getter，根节点状态会作为第三个参数暴露出来：

const moduleA = {
    
    
  // ...
  getters: {
    
    
    sumWithRootCount (state, getters, rootState) {
    
    
      return state.count + rootState.count
    }
  }
}

命名空间

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

const store = new Vuex.Store({
    
    
  modules: {
    
    
    account: {
    
    
      namespaced: true,

      // 模块内容（module assets）
      state: () => ({
    
     ... }), // 模块内的状态已经是嵌套的了，使用 `namespaced` 属性不会对其产生影响
      getters: {
    
    
        isAdmin () {
    
     ... } // -> getters['account/isAdmin']
      },
      actions: {
    
    
        login () {
    
     ... } // -> dispatch('account/login')
      },
      mutations: {
    
    
        login () {
    
     ... } // -> commit('account/login')
      },

      // 嵌套模块
      modules: {
    
    
        // 继承父模块的命名空间
        myPage: {
    
    
          state: () => ({
    
     ... }),
          getters: {
    
    
            profile () {
    
     ... } // -> getters['account/profile']
          }
        },

        // 进一步嵌套命名空间
        posts: {
    
    
          namespaced: true,

          state: () => ({
    
     ... }),
          getters: {
    
    
            popular () {
    
     ... } // -> getters['account/posts/popular']
          }
        }
      }
    }
  }
})

启用了命名空间的 getter 和 action 会收到局部化的 getter，dispatch 和 commit。换言之，你在使用模块内容（module assets）时不需要在同一模块内额外添加空间名前缀。更改 namespaced 属性后不需要修改模块内的代码。

在带命名空间的模块内访问全局内容（Global Assets）

如果你希望使用全局 state 和 getter，rootState 和 rootGetters 会作为第三和第四参数传入 getter，也会通过 context 对象的属性传入 action。
若需要在全局命名空间内分发 action 或提交 mutation，将 { root: true } 作为第三参数传给 dispatch 或 commit 即可。

modules: {
    
    
  foo: {
    
    
    namespaced: true,

    getters: {
    
    
      // 在这个模块的 getter 中，`getters` 被局部化了
      // 你可以使用 getter 的第四个参数来调用 `rootGetters`
      someGetter (state, getters, rootState, rootGetters) {
    
    
        getters.someOtherGetter // -> 'foo/someOtherGetter'
        rootGetters.someOtherGetter // -> 'someOtherGetter'
      },
      someOtherGetter: state => {
    
     ... }
    },

    actions: {
    
    
      // 在这个模块中， dispatch 和 commit 也被局部化了
      // 他们可以接受 `root` 属性以访问根 dispatch 或 commit
      someAction ({
    
     dispatch, commit, getters, rootGetters }) {
    
    
        getters.someGetter // -> 'foo/someGetter'
        rootGetters.someGetter // -> 'someGetter'

        dispatch('someOtherAction') // -> 'foo/someOtherAction'
        dispatch('someOtherAction', null, {
    
     root: true }) // -> 'someOtherAction'

        commit('someMutation') // -> 'foo/someMutation'
        commit('someMutation', null, {
    
     root: true }) // -> 'someMutation'
      },
      someOtherAction (ctx, payload) {
    
     ... }
    }
  }
}

在带命名空间的模块注册全局 action

若需要在带命名空间的模块注册全局 action，你可添加 root: true，并将这个 action 的定义放在函数 handler 中。例如：

{
    
    
  actions: {
    
    
    someOtherAction ({
    
    dispatch}) {
    
    
      dispatch('someAction')
    }
  },
  modules: {
    
    
    foo: {
    
    
      namespaced: true,

      actions: {
    
    
        someAction: {
    
    
          root: true,
          handler (namespacedContext, payload) {
    
     ... } // -> 'someAction'
        }
      }
    }
  }
}

带命名空间的绑定函数

当使用 mapState, mapGetters, mapActions 和 mapMutations 这些函数来绑定带命名空间的模块时，写起来可能比较繁琐：

computed: {
    
    
  ...mapState({
    
    
    a: state => state.some.nested.module.a,
    b: state => state.some.nested.module.b
  })
},
methods: {
    
    
  ...mapActions([
    'some/nested/module/foo', // -> this['some/nested/module/foo']()
    'some/nested/module/bar' // -> this['some/nested/module/bar']()
  ])
}

对于这种情况，你可以将模块的空间名称字符串作为第一个参数传递给上述函数，这样所有绑定都会自动将该模块作为上下文。于是上面的例子可以简化为：

computed: {
    
    
  ...mapState('some/nested/module', {
    
    
    a: state => state.a,
    b: state => state.b
  })
},
methods: {
    
    
  ...mapActions('some/nested/module', [
    'foo', // -> this.foo()
    'bar' // -> this.bar()
  ])
}

而且，你可以通过使用 createNamespacedHelpers 创建基于某个命名空间辅助函数。它返回一个对象，对象里有新的绑定在给定命名空间值上的组件绑定辅助函数：

import {
    
     createNamespacedHelpers } from 'vuex'

const {
    
     mapState, mapActions } = createNamespacedHelpers('some/nested/module')

export default {
    
    
  computed: {
    
    
    // 在 `some/nested/module` 中查找
    ...mapState({
    
    
      a: state => state.a,
      b: state => state.b
    })
  },
  methods: {
    
    
    // 在 `some/nested/module` 中查找
    ...mapActions([
      'foo',
      'bar'
    ])
  }
}

给插件开发者的注意事项

如果你开发的插件（Plugin）提供了模块并允许用户将其添加到 Vuex store，可能需要考虑模块的空间名称问题。对于这种情况，你可以通过插件的参数对象来允许用户指定空间名称：

// 通过插件的参数对象得到空间名称
// 然后返回 Vuex 插件函数
export function createPlugin (options = {
    
    }) {
    
    
  return function (store) {
    
    
    // 把空间名字添加到插件模块的类型（type）中去
    const namespace = options.namespace || ''
    store.dispatch(namespace + 'pluginAction')
  }
}

模块动态注册

在 store 创建之后，你可以使用 store.registerModule 方法注册模块：

import Vuex from 'vuex'

const store = new Vuex.Store({
    
     /* 选项 */ })

// 注册模块 `myModule`
store.registerModule('myModule', {
    
    
  // ...
})
// 注册嵌套模块 `nested/myModule`
store.registerModule(['nested', 'myModule'], {
    
    
  // ...
})

之后就可以通过 store.state.myModule 和 store.state.nested.myModule 访问模块的状态。
模块动态注册功能使得其他 Vue 插件可以通过在 store 中附加新模块的方式来使用 Vuex 管理状态。例如，vuex-router-sync (opens new window)插件就是通过动态注册模块将 vue-router 和 vuex 结合在一起，实现应用的路由状态管理。
你也可以使用 store.unregisterModule(moduleName) 来动态卸载模块。注意，你不能使用此方法卸载静态模块（即创建 store 时声明的模块）。
注意，你可以通过 store.hasModule(moduleName) 方法检查该模块是否已经被注册到 store。

保留 state

在注册一个新 module 时，你很有可能想保留过去的 state，例如从一个服务端渲染的应用保留 state。你可以通过 preserveState 选项将其归档：store.registerModule('a', module, { preserveState: true })。
当你设置 preserveState: true 时，该模块会被注册，action、mutation 和 getter 会被添加到 store 中，但是 state 不会。这里假设 store 的 state 已经包含了这个 module 的 state 并且你不希望将其覆写。

模块重用

有时我们可能需要创建一个模块的多个实例，例如：

创建多个 store，他们公用同一个模块 (例如当 runInNewContext 选项是 false 或 'once' 时，为了在服务端渲染中避免有状态的单例 (opens new window))
在一个 store 中多次注册同一个模块

如果我们使用一个纯对象来声明模块的状态，那么这个状态对象会通过引用被共享，导致状态对象被修改时 store 或模块间数据互相污染的问题。

实际上这和 Vue 组件内的 data 是同样的问题。因此解决办法也是相同的——使用一个函数来声明模块状态（仅 2.3.0+ 支持）：

const MyReusableModule = {
    
    
  state: () => ({
    
    
    foo: 'bar'
  }),
  // mutation, action 和 getter 等等...
}

文件夹的目录组织

Vuex 并不限制你的代码结构。但是，它规定了一些需要遵守的规则：

应用层级的状态应该集中到单个 store 对象中。
提交 mutation 是更改状态的唯一方法，并且这个过程是同步的。
异步逻辑都应该封装到 action 里面。

只要你遵守以上规则，如何组织代码随你便。如果你的 store 文件太大，只需将 action、mutation 和 getter 分割到单独的文件。

对于大型应用，我们会希望把 Vuex 相关代码分割到模块中。下面是项目结构示例：

├── index.html
├── main.js
├── api
│   └── ... # 抽取出API请求
├── components
│   ├── App.vue
│   └── ...
└── store
    ├── index.js          # 我们组装模块并导出 store 的地方
    ├── actions.js        # 根级别的 action
    ├── mutations.js      # 根级别的 mutation
    └── modules
        ├── cart.js       # 购物车模块
        └── products.js   # 产品模块

回顾

Vue笔记一——Vue安装与体验
 Vue笔记二——Vue声明周期与模板语法
 Vue笔记三——计算属性(computed)
Vue笔记四——事件监听的使用
 Vue笔记五——条件判断与循环遍历
 Vue笔记六——书籍购物车案例
 Vue笔记七——v-model表单输入绑定详细介绍
 Vue笔记八——关于组件不可不知的知识！
Vue笔记九——slot插槽的使用
 Vue笔记十——webpack敲重点！！！（详解）
Vue笔记十一——Vue CLI相关
 Vue笔记十二——了解vue-router点进来！！！

Vue笔记十三——Vuex状态管理