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

Jinjiang · web-flow · commit 302a94c48409 · 2017-09-23T00:42:49.000+08:00
* [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
diff --git a/docs/zh-cn/SUMMARY.md b/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)
diff --git a/docs/zh-cn/actions.md b/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: {
diff --git a/docs/zh-cn/api.md b/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#带命名空间的绑定函数)
diff --git a/docs/zh-cn/core-concepts.md b/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 来说是必要的。
 
diff --git a/docs/zh-cn/forms.md b/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">
diff --git a/docs/zh-cn/getters.md b/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,15 +80,15 @@ store.getters.getTodoById(2) // -> { id: 2, text: '...', done: false }
 
 ### `mapGetters` 辅助函数
 
-`mapGetters` 辅助函数仅仅是将 store 中的 getters 映射到局部计算属性：
+`mapGetters` 辅助函数仅仅是将 store 中的 getter 映射到局部计算属性：
 
 ``` js
 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'
 })
 ```
diff --git a/docs/zh-cn/getting-started.md b/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/)示例。
 
diff --git a/docs/zh-cn/hot-reload.md b/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: {
diff --git a/docs/zh-cn/intro.md b/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>
 
 但是，当我们的应用遇到**多个组件共享状态**时，单向数据流的简洁性很容易被破坏：
diff --git a/docs/zh-cn/modules.md b/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'
diff --git a/docs/zh-cn/mutations.md b/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)。
diff --git a/docs/zh-cn/plugins.md b/docs/zh-cn/plugins.md
diff --git a/docs/zh-cn/state.md b/docs/zh-cn/state.md
diff --git a/docs/zh-cn/structure.md b/docs/zh-cn/structure.md
diff --git a/docs/zh-cn/testing.md b/docs/zh-cn/testing.md
