[zh-cn] format & typo (#963)

* [zh-cn] fixed all broken anchors

* [zh-cn] format fixing

* [zh-cn] fixed plural en words

* [zh-cn] small fixes

* [zh-cn] fixed some translation of "helper"

* [zh-cn] small fixes

* [zh-cn] synced #6d314b3 in en

docs/zh-cn/SUMMARY.md

@@ -11,10 +11,10 @@
 - [开始](getting-started.md)
 - [核心概念](core-concepts.md)
   - [State](state.md)
-  - [Getters](getters.md)
-  - [Mutations](mutations.md)
-  - [Actions](actions.md)
-  - [Modules](modules.md)
+  - [Getter](getters.md)
+  - [Mutation](mutations.md)
+  - [Action](actions.md)
+  - [Module](modules.md)
 - [项目结构](structure.md)
 - [插件](plugins.md)
 - [严格模式](strict.md)

docs/zh-cn/actions.md

@@ -1,4 +1,4 @@
-# Actions
+# Action
 
 Action 类似于 mutation，不同在于：
 
@@ -72,7 +72,7 @@ store.dispatch({
 })
 ```
 
-来看一个更加实际的购物车示例，涉及到**调用异步 API** 和 **分发多重 mutations**：
+来看一个更加实际的购物车示例，涉及到**调用异步 API** 和**分发多重 mutation**：
 
 ``` js
 actions: {
@@ -106,23 +106,23 @@ export default {
   // ...
   methods: {
     ...mapActions([
-      'increment', // 将 this.increment() 映射为 this.$store.dispatch('increment')
+      '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')
+      add: 'increment' // 将 `this.add()` 映射为 `this.$store.dispatch('increment')`
     })
   }
 }
 ```
 
-### 组合 Actions
+### 组合 Action
 
 Action 通常是异步的，那么如何知道 action 什么时候结束呢？更重要的是，我们如何才能组合多个 action，以处理更加复杂的异步流程？
 
-首先，你需要明白 `store.dispatch` 可以处理被触发的action的回调函数返回的Promise，并且store.dispatch仍旧返回Promise：
+首先，你需要明白 `store.dispatch` 可以处理被触发的 action 的处理函数返回的 Promise，并且 `store.dispatch` 仍旧返回 Promise：
 
 ``` js
 actions: {

docs/zh-cn/api.md

@@ -127,11 +127,11 @@ const store = new Vuex.Store({ ...options })
 
 - **`commit(type: string, payload?: any, options?: Object) | commit(mutation: Object, options?: Object)`**
 
-  提交 mutation。`options` 里可以有 `root: true`，它允许在[命名空间模块](modules.md#namespacing)里提交根的 mutation。[详细介绍](mutations.md)
+  提交 mutation。`options` 里可以有 `root: true`，它允许在[命名空间模块](modules.md#命名空间)里提交根的 mutation。[详细介绍](mutations.md)
 
 - **`dispatch(type: string, payload?: any, options?: Object) | dispatch(action: Object, options?: Object)`**
 
-  分发 action。`options` 里可以有 `root: true`，它允许在[命名空间模块](modules.md#namespacing)里分发根的 action。返回一个解析所有被触发的 action 处理器的 Promise。[详细介绍](actions.md)
+  分发 action。`options` 里可以有 `root: true`，它允许在[命名空间模块](modules.md#命名空间)里分发根的 action。返回一个解析所有被触发的 action 处理器的 Promise。[详细介绍](actions.md)
 
 - **`replaceState(state: Object)`**
 
@@ -158,11 +158,11 @@ const store = new Vuex.Store({ ...options })
 
 - **`registerModule(path: string | Array<string>, module: Module)`**
 
-  注册一个动态模块。[详细介绍](modules.md#dynamic-module-registration)
+  注册一个动态模块。[详细介绍](modules.md#模块动态注册)
 
 - **`unregisterModule(path: string | Array<string>)`**
 
-  卸载一个动态模块。[详细介绍](modules.md#dynamic-module-registration)
+  卸载一个动态模块。[详细介绍](modules.md#模块动态注册)
 
 - **`hotUpdate(newOptions: Object)`**
 
@@ -172,28 +172,28 @@ const store = new Vuex.Store({ ...options })
 
 - **`mapState(namespace?: string, map: Array<string> | Object): Object`**
 
-  为组件创建计算属性以返回 Vuex store 中的状态。[详细介绍](state.md#the-mapstate-helper)
+  为组件创建计算属性以返回 Vuex store 中的状态。[详细介绍](state.md#mapstate-辅助函数)
 
-  第一个参数是可选的，可以是一个命名空间字符串。[详细介绍](modules.md#binding-helpers-with-namespace)
+  第一个参数是可选的，可以是一个命名空间字符串。[详细介绍](modules.md#带命名空间的绑定函数)
 
 - **`mapGetters(namespace?: string, map: Array<string> | Object): Object`**
 
-  为组件创建计算属性以返回 getter 的返回值。[详细介绍](getters.md#the-mapgetters-helper)
+  为组件创建计算属性以返回 getter 的返回值。[详细介绍](getters.md#mapgetters-辅助函数)
 
-  第一个参数是可选的，可以是一个命名空间字符串。[详细介绍](modules.md#binding-helpers-with-namespace)
+  第一个参数是可选的，可以是一个命名空间字符串。[详细介绍](modules.md#带命名空间的绑定函数)
 
 - **`mapActions(namespace?: string, map: Array<string> | Object): Object`**
 
-  创建组件方法分发 action。[详细介绍](actions.md#dispatching-actions-in-components)
+  创建组件方法分发 action。[详细介绍](actions.md#在组件中分发-action)
 
-  第一个参数是可选的，可以是一个命名空间字符串。[详细介绍](modules.md#binding-helpers-with-namespace)
+  第一个参数是可选的，可以是一个命名空间字符串。[详细介绍](modules.md#带命名空间的绑定函数)
 
 - **`mapMutations(namespace?: string, map: Array<string> | Object): Object`**
 
-  创建组件方法提交 mutation。[详细介绍](mutations.md#commiting-mutations-in-components)
+  创建组件方法提交 mutation。[详细介绍](mutations.md#在组件中提交-mutation)
 
-  第一个参数是可选的，可以是一个命名空间字符串。[详细介绍](modules.md#binding-helpers-with-namespace)
+  第一个参数是可选的，可以是一个命名空间字符串。[详细介绍](modules.md#带命名空间的绑定函数)
 
 - **`createNamespacedHelpers(namespace: string): Object`**
 
-  创建基于命名空间的组件绑定辅助工具。其返回一个包含 `mapState`、`mapGetters`、`mapActions` 和 `mapMutations` 的对象。它们都已经绑定在了给定的命名空间上。[详细介绍](modules.md#binding-helpers-with-namespace)
+  创建基于命名空间的组件绑定辅助函数。其返回一个包含 `mapState`、`mapGetters`、`mapActions` 和 `mapMutations` 的对象。它们都已经绑定在了给定的命名空间上。[详细介绍](modules.md#带命名空间的绑定函数)

docs/zh-cn/core-concepts.md

@@ -2,10 +2,10 @@
 
 在这一章，我们将会学到 Vue 的这些核心概念。他们是：
   - [State](state.md)
-  - [Getters](getters.md)
-  - [Mutations](mutations.md)
-  - [Actions](actions.md)
-  - [Modules](modules.md)
+  - [Getter](getters.md)
+  - [Mutation](mutations.md)
+  - [Action](actions.md)
+  - [Module](modules.md)
 
 深入理解所有的概念对于使用 Vuex 来说是必要的。
 

docs/zh-cn/forms.md

@@ -8,7 +8,7 @@
 
 假设这里的 `obj` 是在计算属性中返回的一个属于 Vuex store 的对象，在用户输入时，`v-model` 会试图直接修改 `obj.message`。在严格模式中，由于这个修改不是在 mutation 函数中执行的, 这里会抛出一个错误。
 
-用『Vuex 的思维』去解决这个问题的方法是：给 `<input>` 中绑定 value，然后侦听 `input` 或者 `change` 事件，在事件回调中调用 action:
+用“Vuex 的思维”去解决这个问题的方法是：给 `<input>` 中绑定 value，然后侦听 `input` 或者 `change` 事件，在事件回调中调用 action:
 
 ``` html
 <input :value="message" @input="updateMessage">

docs/zh-cn/getters.md

@@ -1,5 +1,4 @@
-
-# Getters
+# Getter
 
 有时候我们需要从 store 中的 state 中派生出一些状态，例如对列表进行过滤并计数：
 
@@ -11,11 +10,11 @@ computed: {
 }
 ```
 
-如果有多个组件需要用到此属性，我们要么复制这个函数，或者抽取到一个共享函数然后在多处导入它 —— 无论哪种方式都不是很理想。
+如果有多个组件需要用到此属性，我们要么复制这个函数，或者抽取到一个共享函数然后在多处导入它——无论哪种方式都不是很理想。
 
-Vuex 允许我们在 store 中定义『getters』（可以认为是 store 的计算属性）。就像计算属性一样，getters的返回值会根据它的依赖被缓存起来，且只有当它的依赖值发生了改变才会被重新计算。
+Vuex 允许我们在 store 中定义“getter”（可以认为是 store 的计算属性）。就像计算属性一样，getter 的返回值会根据它的依赖被缓存起来，且只有当它的依赖值发生了改变才会被重新计算。
 
-Getters 接受 state 作为其第一个参数：
+Getter 接受 state 作为其第一个参数：
 
 ``` js
 const store = new Vuex.Store({
@@ -33,13 +32,13 @@ const store = new Vuex.Store({
 })
 ```
 
-Getters 会暴露为 `store.getters` 对象：
+Getter 会暴露为 `store.getters` 对象：
 
 ``` js
 store.getters.doneTodos // -> [{ id: 1, text: '...', done: true }]
 ```
 
-Getters 也可以接受其他 getters 作为第二个参数：
+Getter 也可以接受其他 getter 作为第二个参数：
 
 ``` js
 getters: {
@@ -81,7 +80,7 @@ store.getters.getTodoById(2) // -> { id: 2, text: '...', done: false }
 
 ### `mapGetters` 辅助函数
 
-`mapGetters` 辅助函数仅仅是将 store 中的 getters 映射到局部计算属性：
+`mapGetters` 辅助函数仅仅是将 store 中的 getter 映射到局部计算属性：
 
 ``` js
 import { mapGetters } from 'vuex'
@@ -89,7 +88,7 @@ import { mapGetters } from 'vuex'
 export default {
   // ...
   computed: {
-  // 使用对象展开运算符将 getters 混入 computed 对象中
+  // 使用对象展开运算符将 getter 混入 computed 对象中
     ...mapGetters([
       'doneTodosCount',
       'anotherGetter',
@@ -103,7 +102,7 @@ export default {
 
 ``` js
 mapGetters({
-  // 映射 this.doneCount 为 store.getters.doneTodosCount
+  // 映射 `this.doneCount` 为 `store.getters.doneTodosCount`
   doneCount: 'doneTodosCount'
 })
 ```

docs/zh-cn/getting-started.md

@@ -1,16 +1,16 @@
 # 开始
 
-每一个 Vuex 应用的核心就是 store（仓库）。"store" 基本上就是一个容器，它包含着你的应用中大部分的**状态(state)**。Vuex 和单纯的全局对象有以下两点不同：
+每一个 Vuex 应用的核心就是 store（仓库）。“store”基本上就是一个容器，它包含着你的应用中大部分的**状态 (state)**。Vuex 和单纯的全局对象有以下两点不同：
 
 1. Vuex 的状态存储是响应式的。当 Vue 组件从 store 中读取状态的时候，若 store 中的状态发生变化，那么相应的组件也会相应地得到高效更新。
 
-2. 你不能直接改变 store 中的状态。改变 store 中的状态的唯一途径就是显式地**提交(commit) mutations**。这样使得我们可以方便地跟踪每一个状态的变化，从而让我们能够实现一些工具帮助我们更好地了解我们的应用。
+2. 你不能直接改变 store 中的状态。改变 store 中的状态的唯一途径就是显式地**提交 (commit) mutation**。这样使得我们可以方便地跟踪每一个状态的变化，从而让我们能够实现一些工具帮助我们更好地了解我们的应用。
 
 ### 最简单的 Store
 
 > **提示：**我们将在后续的文档示例代码中使用 ES2015 语法。如果你还没能掌握 ES2015，[你得抓紧了](https://babeljs.io/docs/learn-es2015/)！
 
-[安装](installation.md) Vuex 之后，让我们来创建一个 store。创建过程直截了当——仅需要提供一个初始 state 对象和一些 mutations：
+[安装](installation.md) Vuex 之后，让我们来创建一个 store。创建过程直截了当——仅需要提供一个初始 state 对象和一些 mutation：
 
 ``` js
 // 如果在模块化构建系统中，请确保在开头调用了 Vue.use(Vuex)
@@ -37,7 +37,7 @@ console.log(store.state.count) // -> 1
 
 再次强调，我们通过提交 mutation 的方式，而非直接改变 `store.state.count`，是因为我们想要更明确地追踪到状态的变化。这个简单的约定能够让你的意图更加明显，这样你在阅读代码的时候能更容易地解读应用内部的状态改变。此外，这样也让我们有机会去实现一些能记录每次状态改变，保存状态快照的调试工具。有了它，我们甚至可以实现如时间穿梭般的调试体验。
 
-由于 store 中的状态是响应式的，在组件中调用 store 中的状态简单到仅需要在计算属性中返回即可。触发变化也仅仅是在组件的 methods 中提交 mutations。
+由于 store 中的状态是响应式的，在组件中调用 store 中的状态简单到仅需要在计算属性中返回即可。触发变化也仅仅是在组件的 methods 中提交 mutation。
 
 这是一个[最基本的 Vuex 记数应用](https://jsfiddle.net/n9jmu5v7/1269/)示例。
 

docs/zh-cn/hot-reload.md

@@ -1,6 +1,6 @@
 # 热重载
 
-使用 webpack 的 [Hot Module Replacement API](https://webpack.github.io/docs/hot-module-replacement.html)，Vuex 支持在开发过程中热重载 mutation、modules、actions、和getters。你也可以在 Browserify 中使用 [browserify-hmr](https://github.com/AgentME/browserify-hmr/) 插件。
+使用 webpack 的 [Hot Module Replacement API](https://webpack.github.io/docs/hot-module-replacement.html)，Vuex 支持在开发过程中热重载 mutation、module、action 和 getter。你也可以在 Browserify 中使用 [browserify-hmr](https://github.com/AgentME/browserify-hmr/) 插件。
 
 对于 mutation 和模块，你需要使用 `store.hotUpdate()` 方法：
 
@@ -24,13 +24,13 @@ const store = new Vuex.Store({
 })
 
 if (module.hot) {
-  // 使 actions 和 mutations 成为可热重载模块
+  // 使 action 和 mutation 成为可热重载模块
   module.hot.accept(['./mutations', './modules/a'], () => {
     // 获取更新后的模块
-    // 因为 babel 6 的模块编译格式问题，这里需要加上 .default
+    // 因为 babel 6 的模块编译格式问题，这里需要加上 `.default`
     const newMutations = require('./mutations').default
     const newModuleA = require('./modules/a').default
-    // 加载新模块 
+    // 加载新模块
     store.hotUpdate({
       mutations: newMutations,
       modules: {

docs/zh-cn/intro.md

@@ -30,13 +30,13 @@ new Vue({
 这个状态自管理应用包含以下几个部分：
 
 - **state**，驱动应用的数据源；
-- **view**，以声明方式将**state**映射到视图；
-- **actions**，响应在**view**上的用户输入导致的状态变化。
+- **view**，以声明方式将 **state** 映射到视图；
+- **actions**，响应在 **view** 上的用户输入导致的状态变化。
 
 以下是一个表示“单向数据流”理念的极简示意：
 
-<p style="text-align: center; margin: 2em">
-  <img style="width:100%;max-width:450px;" src="./images/flow.png">
+<p style="text-align: center; margin: 2em;">
+  <img style="width: 100%; max-width: 450px;" src="./images/flow.png">
 </p>
 
 但是，当我们的应用遇到**多个组件共享状态**时，单向数据流的简洁性很容易被破坏：

docs/zh-cn/modules.md

@@ -1,4 +1,4 @@
-# Modules
+# Module
 
 由于使用单一状态树，应用的所有状态会集中到一个比较大的对象。当应用变得非常复杂时，store 对象就有可能变得相当臃肿。
 
@@ -51,7 +51,7 @@ const moduleA = {
 }
 ```
 
-同样，对于模块内部的 action，局部状态通过 `context.state` 暴露出来， 根节点状态则为 `context.rootState`：
+同样，对于模块内部的 action，局部状态通过 `context.state` 暴露出来，根节点状态则为 `context.rootState`：
 
 ``` js
 const moduleA = {
@@ -206,7 +206,7 @@ methods: {
 }
 ```
 
-而且，你可以通过使用 `createNamespacedHelpers` 创建基于某个命名空间辅助工具。它返回一个对象，对象里有新的绑定在给定命名空间值上的组件绑定辅助工具：
+而且，你可以通过使用 `createNamespacedHelpers` 创建基于某个命名空间辅助函数。它返回一个对象，对象里有新的绑定在给定命名空间值上的组件绑定辅助函数：
 
 ``` js
 import { createNamespacedHelpers } from 'vuex'

docs/zh-cn/mutations.md

@@ -1,6 +1,6 @@
-# Mutations
+# Mutation
 
-更改 Vuex 的 store 中的状态的唯一方法是提交 mutation。Vuex 中的 mutations 非常类似于事件：每个 mutation 都有一个字符串的 **事件类型 (type)** 和 一个 **回调函数 (handler)**。这个回调函数就是我们实际进行状态更改的地方，并且它会接受 state 作为第一个参数：
+更改 Vuex 的 store 中的状态的唯一方法是提交 mutation。Vuex 中的 mutation 非常类似于事件：每个 mutation 都有一个字符串的 **事件类型 (type)** 和 一个 **回调函数 (handler)**。这个回调函数就是我们实际进行状态更改的地方，并且它会接受 state 作为第一个参数：
 
 ``` js
 const store = new Vuex.Store({
@@ -76,7 +76,7 @@ mutations: {
 }
 ```
 
-### Mutations 需遵守 Vue 的响应规则
+### Mutation 需遵守 Vue 的响应规则
 
 既然 Vuex 的 store 中的状态是响应式的，那么当我们变更状态时，监视状态的 Vue 组件也会自动更新。这也意味着 Vuex 中的 mutation 也需要与使用 Vue 一样遵守一些注意事项：
 
@@ -117,7 +117,7 @@ const store = new Vuex.Store({
 })
 ```
 
-用不用常量取决于你 —— 在需要多人协作的大型项目中，这会很有帮助。但如果你不喜欢，你完全可以不这样做。
+用不用常量取决于你——在需要多人协作的大型项目中，这会很有帮助。但如果你不喜欢，你完全可以不这样做。
 
 ### Mutation 必须是同步函数
 
@@ -133,9 +133,9 @@ mutations: {
 }
 ```
 
-现在想象，我们正在 debug 一个 app 并且观察 devtool 中的 mutation 日志。每一条 mutation 被记录，devtools 都需要捕捉到前一状态和后一状态的快照。然而，在上面的例子中 mutation 中的异步函数中的回调让这不可能完成：因为当 mutation 触发的时候，回调函数还没有被调用，devtools 不知道什么时候回调函数实际上被调用 —— 实质上任何在回调函数中进行的的状态的改变都是不可追踪的。
+现在想象，我们正在 debug 一个 app 并且观察 devtool 中的 mutation 日志。每一条 mutation 被记录，devtools 都需要捕捉到前一状态和后一状态的快照。然而，在上面的例子中 mutation 中的异步函数中的回调让这不可能完成：因为当 mutation 触发的时候，回调函数还没有被调用，devtools 不知道什么时候回调函数实际上被调用——实质上任何在回调函数中进行的的状态的改变都是不可追踪的。
 
-### 在组件中提交 Mutations
+### 在组件中提交 Mutation
 
 你可以在组件中使用 `this.$store.commit('xxx')` 提交 mutation，或者使用 `mapMutations` 辅助函数将组件中的 methods 映射为 `store.commit` 调用（需要在根节点注入 `store`）。
 
@@ -146,19 +146,19 @@ export default {
   // ...
   methods: {
     ...mapMutations([
-      'increment', // 将 this.increment() 映射为 this.$store.commit('increment')
+      'increment', // 将 `this.increment()` 映射为 `this.$store.commit('increment')`
 
       // `mapMutations` 也支持载荷：
       'incrementBy' // 将 `this.incrementBy(amount)` 映射为 `this.$store.commit('incrementBy', amount)`
     ]),
     ...mapMutations({
-      add: 'increment' // 将 this.add() 映射为 this.$store.commit('increment')
+      add: 'increment' // 将 `this.add()` 映射为 `this.$store.commit('increment')`
     })
   }
 }
 ```
 
-### 下一步：Actions
+### 下一步：Action
 
 在 mutation 中混合异步调用会导致你的程序很难调试。例如，当你能调用了两个包含异步回调的 mutation 来改变状态，你怎么知道什么时候回调和哪个先回调呢？这就是为什么我们要区分这两个概念。在 Vuex 中，**mutation 都是同步事务**：
 
@@ -167,4 +167,4 @@ store.commit('increment')
 // 任何由 "increment" 导致的状态变更都应该在此刻完成。
 ```
 
-为了处理异步操作，让我们来看一看 [Actions](actions.md)。
+为了处理异步操作，让我们来看一看 [Action](actions.md)。

docs/zh-cn/plugins.md

@@ -54,7 +54,7 @@ const store = new Vuex.Store({
 
 ### 生成 State 快照
 
-有时候插件需要获得状态的『快照』，比较改变的前后状态。想要实现这项功能，你需要对状态对象进行深拷贝：
+有时候插件需要获得状态的“快照”，比较改变的前后状态。想要实现这项功能，你需要对状态对象进行深拷贝：
 
 ``` js
 const myPluginWithSnapshot = store => {

docs/zh-cn/state.md

@@ -2,9 +2,9 @@
 
 ### 单一状态树
 
-Vuex 使用 **单一状态树** —— 是的，用一个对象就包含了全部的应用层级状态。至此它便作为一个『唯一数据源([SSOT](https://en.wikipedia.org/wiki/Single_source_of_truth))』而存在。这也意味着，每个应用将仅仅包含一个 store 实例。单一状态树让我们能够直接地定位任一特定的状态片段，在调试的过程中也能轻易地取得整个当前应用状态的快照。
+Vuex 使用**单一状态树**——是的，用一个对象就包含了全部的应用层级状态。至此它便作为一个“唯一数据源 ([SSOT](https://en.wikipedia.org/wiki/Single_source_of_truth))”而存在。这也意味着，每个应用将仅仅包含一个 store 实例。单一状态树让我们能够直接地定位任一特定的状态片段，在调试的过程中也能轻易地取得整个当前应用状态的快照。
 
-单状态树和模块化并不冲突 —— 在后面的章节里我们会讨论如何将状态和状态变更事件分布到各个子模块中。
+单状态树和模块化并不冲突——在后面的章节里我们会讨论如何将状态和状态变更事件分布到各个子模块中。
 
 ### 在 Vue 组件中获得 Vuex 状态
 
@@ -26,7 +26,7 @@ const Counter = {
 
 然而，这种模式导致组件依赖全局状态单例。在模块化的构建系统中，在每个需要使用 state 的组件中需要频繁地导入，并且在测试组件时需要模拟状态。
 
-Vuex 通过 `store` 选项，提供了一种机制将状态从根组件『注入』到每一个子组件中（需调用 `Vue.use(Vuex)`）：
+Vuex 通过 `store` 选项，提供了一种机制将状态从根组件“注入”到每一个子组件中（需调用 `Vue.use(Vuex)`）：
 
 ``` js
 const app = new Vue({

docs/zh-cn/structure.md

@@ -8,7 +8,7 @@ Vuex 并不限制你的代码结构。但是，它规定了一些需要遵守的
 
 3. 异步逻辑都应该封装到 **action** 里面。
 
-只要你遵守以上规则，如何组织代码随你便。如果你的 store 文件太大，只需将 action、mutation 和 getters 分割到单独的文件。
+只要你遵守以上规则，如何组织代码随你便。如果你的 store 文件太大，只需将 action、mutation 和 getter 分割到单独的文件。
 
 对于大型应用，我们会希望把 Vuex 相关代码分割到模块中。下面是项目结构示例：
 
@@ -30,4 +30,4 @@ Vuex 并不限制你的代码结构。但是，它规定了一些需要遵守的
         └── products.js   # 产品模块
 ```
 
-请参考[购物车示例](https://github.com/vuejs/vuex/tree/dev/examples/shopping-cart)
+请参考[购物车示例](https://github.com/vuejs/vuex/tree/dev/examples/shopping-cart)。

docs/zh-cn/testing.md

@@ -1,15 +1,15 @@
 # 测试
 
-我们主要想针对 Vuex 中的 mutations 和 actions 进行单元测试。
+我们主要想针对 Vuex 中的 mutation 和 action 进行单元测试。
 
-### 测试 Mutations
+### 测试 Mutation
 
-Mutations 很容易被测试，因为它们仅仅是一些完全依赖参数的函数。这里有一个小技巧，如果你在 `store.js` 文件中定义了 mutations，并且使用 ES2015 模块功能默认输出了 Vuex.Store 的实例，那么你仍然可以给 mutation 取个变量名然后把它输出去：
+Mutation 很容易被测试，因为它们仅仅是一些完全依赖参数的函数。这里有一个小技巧，如果你在 `store.js` 文件中定义了 mutation，并且使用 ES2015 模块功能默认输出了 Vuex.Store 的实例，那么你仍然可以给 mutation 取个变量名然后把它输出去：
 
 ``` js
 const state = { ... }
 
-// mutations 作为命名输出对象
+// `mutations` 作为命名输出对象
 export const mutations = { ... }
 
 export default new Vuex.Store({
@@ -32,7 +32,7 @@ export const mutations = {
 import { expect } from 'chai'
 import { mutations } from './store'
 
-// 解构 mutations
+// 解构 `mutations`
 const { increment } = mutations
 
 describe('mutations', () => {
@@ -47,9 +47,9 @@ describe('mutations', () => {
 })
 ```
 
-### 测试 Actions
+### 测试 Action
 
-Actions 应对起来略微棘手，因为它们可能需要调用外部的 API。当测试 actions 的时候，我们需要增加一个 mocking 服务层 —— 例如，我们可以把 API 调用抽象成服务，然后在测试文件中用 mock 服务回应 API 调用。为了便于解决 mock 依赖，可以用 webpack 和  [inject-loader](https://github.com/plasticine/inject-loader) 打包测试文件。
+Action 应对起来略微棘手，因为它们可能需要调用外部的 API。当测试 action 的时候，我们需要增加一个 mocking 服务层——例如，我们可以把 API 调用抽象成服务，然后在测试文件中用 mock 服务回应 API 调用。为了便于解决 mock 依赖，可以用 webpack 和  [inject-loader](https://github.com/plasticine/inject-loader) 打包测试文件。
 
 下面是一个测试异步 action 的例子：
 
@@ -71,7 +71,7 @@ export const getAllProducts = ({ commit }) => {
 // 使用 require 语法处理内联 loaders。
 // inject-loader 返回一个允许我们注入 mock 依赖的模块工厂
 import { expect } from 'chai'
-const actionsInjector = require('inject!./actions')
+const actionsInjector = require('inject-loader!./actions')
 
 // 使用 mocks 创建模块
 const actions = actionsInjector({
@@ -127,7 +127,7 @@ describe('actions', () => {
 })
 ```
 
-### 测试 Getters
+### 测试 Getter
 
 如果你的 getter 包含很复杂的计算过程，很有必要测试它们。Getter 的测试与 mutation 一样直截了当。
 
@@ -176,7 +176,7 @@ describe('getters', () => {
 
 ### 执行测试
 
-如果你的 mutations 和 actions 编写正确，经过合理地 mocking 处理之后这些测试应该不依赖任何浏览器 API，因此你可以直接用 webpack 打包这些测试文件然后在 Node 中执行。换种方式，你也可以用 `mocha-loader` 或 `Karma` + `karma-webpack`在真实浏览器环境中进行测试。
+如果你的 mutation 和 action 编写正确，经过合理地 mocking 处理之后这些测试应该不依赖任何浏览器 API，因此你可以直接用 webpack 打包这些测试文件然后在 Node 中执行。换种方式，你也可以用 `mocha-loader` 或 Karma + `karma-webpack`在真实浏览器环境中进行测试。
 
 #### 在 Node 中执行测试
 
@@ -211,10 +211,10 @@ mocha test-bundle.js
 
 #### 在浏览器中测试
 
-1. 安装 `mocha-loader`
-2. 把上述 webpack 配置中的 `entry` 改成 `'mocha!babel!./test.js'`
-3. 用以上配置启动 `webpack-dev-server`
-4. 访问 `localhost:8080/webpack-dev-server/test-bundle`.
+1. 安装 `mocha-loader`。
+2. 把上述 webpack 配置中的 `entry` 改成 `'mocha-loader!babel-loader!./test.js'`。
+3. 用以上配置启动 `webpack-dev-server`。
+4. 访问 `localhost:8080/webpack-dev-server/test-bundle`。
 
 #### 使用 Karma + karma-webpack 在浏览器中执行测试