Vue狀態管理vuex

前面的話

　　由於多個狀態分散的跨越在許多組件和交互間各個角落，大型應用複雜度也經常逐漸增長。為瞭解決這個問題，Vue提供了vuex。本文將詳細介紹Vue狀態管理vuex

引入

　　當訪問數據對象時，一個 Vue 實例只是簡單的代理訪問。所以，如果有一處需要被多個實例間共用的狀態，可以簡單地通過維護一份數據來實現共用

const sourceOfTruth = {}
const vmA = new Vue({
  data: sourceOfTruth
})
const vmB = new Vue({
  data: sourceOfTruth
})

　　現在當 sourceOfTruth 發生變化，vmA 和 vmB 都將自動的更新引用它們的視圖。子組件們的每個實例也會通過 this.$root.$data 去訪問。現在有了唯一的實際來源，但是，調試將會變為噩夢。任何時間，應用中的任何部分，在任何數據改變後，都不會留下變更過的記錄。

　　為瞭解決這個問題，採用一個簡單的 store 模式：

var store = {
  debug: true,
  state: {
    message: 'Hello!'
  },
  setMessageAction (newValue) {
    if (this.debug) console.log('setMessageAction triggered with', newValue)
    this.state.message = newValue
  },
  clearMessageAction () {
    if (this.debug) console.log('clearMessageAction triggered')
    this.state.message = ''
  }
}

　　所有 store 中 state 的改變，都放置在 store 自身的 action 中去管理。這種集中式狀態管理能夠被更容易地理解哪種類型的 mutation 將會發生，以及它們是如何被觸發。當錯誤出現時，現在也會有一個 log 記錄 bug 之前發生了什麼

　　此外，每個實例/組件仍然可以擁有和管理自己的私有狀態：

var vmA = new Vue({
  data: {
    privateState: {},
    sharedState: store.state
  }
})
var vmB = new Vue({
  data: {
    privateState: {},
    sharedState: store.state
  }
})

　　[註意]不應該在action中替換原始的狀態對象，組件和store需要引用同一個共用對象，mutation才能夠被觀察

　　接著繼續延伸約定，組件不允許直接修改屬於 store 實例的 state，而應執行 action 來分發 (dispatch) 事件通知 store 去改變，最終達成了 Flux 架構。這樣約定的好處是，能夠記錄所有 store 中發生的 state 改變，同時實現能做到記錄變更 (mutation)、保存狀態快照、歷史回滾/時光旅行的先進的調試工具

概述

　　Vuex 是一個專為 Vue.js 應用程式開發的狀態管理模式。它採用集中式存儲管理應用的所有組件的狀態，並以相應的規則保證狀態以一種可預測的方式發生變化。Vuex提供了諸如零配置的 time-travel 調試、狀態快照導入導出等高級調試功能

【狀態管理模式】

　　下麵以一個簡單的計數應用為例，來說明狀態管理模式

new Vue({
  el: '#app',
  // state
  data () {
    return {
      count: 0
    }
  },
  // view
  template: `
  <div>
    <span>{{count}}</span>
    <input type="button" value="+" @click="increment">
  </div>
  `,
  // actions
  methods: {
    increment () {
      this.count++
    }
  }
})

　　這個狀態自管理應用包含以下幾個部分：

state，驅動應用的數據源；
view，以聲明方式將 state 映射到視圖；
actions，響應在 view 上的用戶輸入導致的狀態變化。

　　下麵是一個表示“單向數據流”理念的極簡示意：

　　但是，當應用遇到多個組件共用狀態時，單向數據流的簡潔性很容易被破壞，存在以下兩個問題

　　1、多個視圖依賴於同一狀態

　　2、來自不同視圖的行為需要變更同一狀態

　　對於問題一，傳參的方法對於多層嵌套的組件將會非常繁瑣，並且對於兄弟組件間的狀態傳遞無能為力。對於問題二，經常會採用父子組件直接引用或者通過事件來變更和同步狀態的多份拷貝。以上的這些模式非常脆弱，通常會導致無法維護的代碼。

　　因此，為什麼不把組件的共用狀態抽取出來，以一個全局單例模式管理呢？在這種模式下，組件樹構成了一個巨大的“視圖”，不管在樹的哪個位置，任何組件都能獲取狀態或者觸發行為

　　另外，通過定義和隔離狀態管理中的各種概念並強制遵守一定的規則，代碼將會變得更結構化且易維護。

　　這就是 Vuex 背後的基本思想，借鑒了 Flux、Redux、和 The Elm Architecture。與其他模式不同的是，Vuex 是專門為 Vue.js 設計的狀態管理庫，以利用 Vue.js 的細粒度數據響應機制來進行高效的狀態更新

【使用情況】

　　雖然 Vuex 可以幫助管理共用狀態，但也附帶了更多的概念和框架。這需要對短期和長期效益進行權衡。

　　如果不打算開發大型單頁應用，使用 Vuex 可能是繁瑣冗餘的。確實是如此——如果應用夠簡單，最好不要使用 Vuex。一個簡單的 global event bus 就足夠所需了。但是，如果需要構建是一個中大型單頁應用，很可能會考慮如何更好地在組件外部管理狀態，Vuex 將會成為自然而然的選擇

開始

【安裝】

npm install vuex --save

　　在一個模塊化的打包系統中，必須顯式地通過 Vue.use() 來安裝 Vuex

import Vue from 'vue'
import Vuex from 'vuex'

Vue.use(Vuex)

　　當使用全局 script 標簽引用 Vuex 時，不需要以上安裝過程

【概述】

　　每一個 Vuex 應用的核心就是 store（倉庫）。“store”基本上就是一個容器，它包含著應用中大部分的狀態 (state)。Vuex 和單純的全局對象有以下兩點不同：

　　1、Vuex 的狀態存儲是響應式的。當 Vue 組件從 store 中讀取狀態的時候，若 store 中的狀態發生變化，那麼相應的組件也會相應地得到高效更新

　　2、不能直接改變 store 中的狀態。改變 store 中的狀態的唯一途徑就是顯式地提交 (commit) mutation。這樣使得可以方便地跟蹤每一個狀態的變化，從而能夠實現一些工具幫助更好地瞭解應用

【最簡單的store】

　　下麵來創建一個 store。創建過程直截了當——僅需要提供一個初始 state 對象和一些 mutation

// 如果在模塊化構建系統中，請確保在開頭調用了 Vue.use(Vuex)
const store = new Vuex.Store({
  state: {
    count: 0
  },
  mutations: {
    increment (state) {
      state.count++
    }
  }
})

　　現在，可以通過 store.state 來獲取狀態對象，以及通過 store.commit 方法觸髮狀態變更：

store.commit('increment')
console.log(store.state.count) // -> 1

　　通過提交 mutation 的方式，而非直接改變 store.state.count，是因為想要更明確地追蹤到狀態的變化。這個簡單的約定能夠讓意圖更加明顯，這樣在閱讀代碼的時候能更容易地解讀應用內部的狀態改變。此外，這樣也有機會去實現一些能記錄每次狀態改變，保存狀態快照的調試工具。有了它，甚至可以實現如時間穿梭般的調試體驗。

　　由於 store 中的狀態是響應式的，在組件中調用 store 中的狀態簡單到僅需要在計算屬性中返回即可。觸發變化也僅僅是在組件的 methods 中提交 mutation

　　下麵是一個使用vuex實現的簡單計數器

const store = new Vuex.Store({
  state: {
    count: 0
  },
  mutations: {
    increment: state => state.count++,
    decrement: state => state.count--,
  }
})
new Vue({
  el: '#app',
  computed: {
    count () {
      return store.state.count
    }
  },
  // view
  template: `
  <div>
    <input type="button" value="-" @click="decrement">
    <span>{{count}}</span>
    <input type="button" value="+" @click="increment">
  </div>
  `,
  // actions
  methods: {
    increment () {
      store.commit('increment')
    },
    decrement () {
      store.commit('decrement')
    },    
  }
})

核心概念

state

【單一狀態樹】

　　Vuex 使用單一狀態樹——用一個對象就包含了全部的應用層級狀態。至此它便作為一個“唯一數據源 (SSOT)”而存在。這也意味著，每個應用將僅僅包含一個 store 實例。單一狀態樹能夠直接地定位任一特定的狀態片段，在調試的過程中也能輕易地取得整個當前應用狀態的快照

【在VUE組件中獲得VUEX狀態】

　　如何在 Vue 組件中展示狀態呢？由於 Vuex 的狀態存儲是響應式的，從 store 實例中讀取狀態最簡單的方法就是在計算屬性中返回某個狀態

// 創建一個 Counter 組件
const Counter = {
  template: `<div>{{ count }}</div>`,
  computed: {
    count () {
      return store.state.count
    }
  }
}

　　每當 store.state.count 變化的時候, 都會重新求取計算屬性，並且觸發更新相關聯的 DOM

　　然而，這種模式導致組件依賴全局狀態單例。在模塊化的構建系統中，在每個需要使用 state 的組件中需要頻繁地導入，並且在測試組件時需要模擬狀態。

　　Vuex 通過 store 選項，提供了一種機制將狀態從根組件“註入”到每一個子組件中（需調用 Vue.use(Vuex)）：

const app = new Vue({
  el: '#app',
  // 把 store 對象提供給 “store” 選項，這可以把 store 的實例註入所有的子組件
  store,
  components: { Counter },
  template: `
    <div class="app">
      <counter></counter>
    </div>
  `
})

　　通過在根實例中註冊 store 選項，該 store 實例會註入到根組件下的所有子組件中，且子組件能通過this.$store訪問到。下麵來更新下 Counter 的實現：

const Counter = {
  template: `<div>{{ count }}</div>`,
  computed: {
    count () {
      return this.$store.state.count
    }
  }
}

【mapState輔助函數】

　　當一個組件需要獲取多個狀態時，將這些狀態都聲明為計算屬性會有些重覆和冗餘。為瞭解決這個問題，可以使用mapState輔助函數幫助生成計算屬性

// 在單獨構建的版本中輔助函數為 Vuex.mapState
import { mapState } from 'vuex'

export default {
  // ...
  computed: mapState({
    // 箭頭函數可使代碼更簡練
    count: state => state.count,

    // 傳字元串參數 'count' 等同於 `state => state.count`
    countAlias: 'count',

    // 為了能夠使用 `this` 獲取局部狀態，必須使用常規函數
    countPlusLocalState (state) {
      return state.count + this.localCount
    }
  })
}

　　當映射的計算屬性的名稱與 state 的子節點名稱相同時，也可以給 mapState 傳一個字元串數組

computed: mapState([
  // 映射 this.count 為 store.state.count
  'count'
])

【對象展開運算符】

　　mapState 函數返回的是一個對象。如何將它與局部計算屬性混合使用呢？通常，需要使用一個工具函數將多個對象合併為一個，將最終對象傳給 computed 屬性。但是自從有了對象展開運算符，可以極大地簡化寫法：

computed: {
  localComputed () { /* ... */ },
  // 使用對象展開運算符將此對象混入到外部對象中
  ...mapState({
    // ...
  })
}

【組件仍然保有局部狀態】

　　使用 Vuex 並不意味著需要將所有的狀態放入 Vuex。雖然將所有的狀態放到 Vuex 會使狀態變化更顯式和易調試，但也會使代碼變得冗長和不直觀。如果有些狀態嚴格屬於單個組件，最好還是作為組件的局部狀態

Getter

　　有時候需要從 store 中的 state 中派生出一些狀態，例如對列表進行過濾並計數：

computed: {
  doneTodosCount () {
    return this.$store.state.todos.filter(todo => todo.done).length
  }
}

　　如果有多個組件需要用到此屬性，要麼複製這個函數，或者抽取到一個共用函數然後在多處導入它——無論哪種方式都不是很理想

　　Vuex 允許在 store 中定義“getter”（可以認為是 store 的計算屬性）。就像計算屬性一樣，getter 的返回值會根據它的依賴被緩存起來，且只有當它的依賴值發生了改變才會被重新計算

　　Getter 接受 state 作為其第一個參數：

const store = new Vuex.Store({
  state: {
    todos: [
      { id: 1, text: '...', done: true },
      { id: 2, text: '...', done: false }
    ]
  },
  getters: {
    doneTodos: state => {
      return state.todos.filter(todo => todo.done)
    }
  }
})

　　Getter 會暴露為 store.getters 對象：

store.getters.doneTodos // -> [{ id: 1, text: '...', done: true }]

　　Getter 也可以接受其他 getter 作為第二個參數：

getters: {
  // ...
  doneTodosCount: (state, getters) => {
    return getters.doneTodos.length
  }
}
store.getters.doneTodosCount // -> 1

　　可以很容易地在任何組件中使用它：

computed: {
  doneTodosCount () {
    return this.$store.getters.doneTodosCount
  }
}

　　也可以通過讓 getter 返回一個函數，來實現給 getter 傳參。在對 store 里的數組進行查詢時非常有用

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

　　如果箭頭函數不好理解，翻譯成普通函數如下

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

【mapGetters輔助函數】

　　mapGetters 輔助函數僅僅是將 store 中的 getter 映射到局部計算屬性：

import { mapGetters } from 'vuex'

export default {
  // ...
  computed: {
  // 使用對象展開運算符將 getter 混入 computed 對象中
    ...mapGetters([
      'doneTodosCount',
      'anotherGetter',
      // ...
    ])
  }
}

　　如果想將一個 getter 屬性另取一個名字，使用對象形式：

mapGetters({
  // 映射 `this.doneCount` 為 `store.getters.doneTodosCount`
  doneCount: 'doneTodosCount'
})

mutation

　　更改 Vuex 的 store 中的狀態的唯一方法是提交 mutation。Vuex 中的 mutation 非常類似於事件：每個 mutation 都有一個字元串的 事件類型 (type) 和 一個 回調函數 (handler)。這個回調函數就是實際進行狀態更改的地方，並且它會接受 state 作為第一個參數：

const store = new Vuex.Store({
  state: {
    count: 1
  },
  mutations: {
    increment (state) {
      // 變更狀態
      state.count++
    }
  }
})

　　不能直接調用一個 mutation handler。這個選項更像是事件註冊：“當觸發一個類型為 increment 的 mutation 時，調用此函數。”要喚醒一個 mutation handler，需要以相應的 type 調用 store.commit 方法：

store.commit('increment')

【提交載荷(Payload)】

　　可以向 store.commit 傳入額外的參數，即 mutation 的 載荷（payload）

// ...
mutations: {
  increment (state, n) {
    state.count += n
  }
}
store.commit('increment', 10)

　　在大多數情況下，載荷應該是一個對象，這樣可以包含多個欄位並且記錄的 mutation 會更易讀：

// ...
mutations: {
  increment (state, payload) {
    state.count += payload.amount
  }
}
store.commit('increment', {
  amount: 10
})

【對象風格的提交方式】

　　提交 mutation 的另一種方式是直接使用包含 type 屬性的對象

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

　　當使用對象風格的提交方式，整個對象都作為載荷傳給 mutation 函數，因此 handler 保持不變：

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

【遵守響應規則】

　　既然 Vuex 的 store 中的狀態是響應式的，那麼當變更狀態時，監視狀態的 Vue 組件也會自動更新。這也意味著 Vuex 中的 mutation 也需要與使用 Vue 一樣遵守一些註意事項：

　　1、最好提前在store中初始化好所有所需屬性

　　2、當需要在對象上添加新屬性時，應該使用 Vue.set(obj, 'newProp', 123), 或者以新對象替換老對象

　　例如，利用對象展開運算符可以這樣寫：

state.obj = { ...state.obj, newProp: 123 }

【使用常量替代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 不知道什麼時候回調函數實際上被調用——實質上任何在回調函數中進行的狀態改變都是不可追蹤的

【在組件中提交Mutation】

　　可以在組件中使用 this.$store.commit('xxx') 提交 mutation，或者使用 mapMutations 輔助函數將組件中的 methods 映射為 store.commit 調用（需要在根節點註入 store）

import { mapMutations } from 'vuex'

export default {
  // ...
  methods: {
    ...mapMutations([
      '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')`
    })
  }
}

action

　　在 mutation 中混合非同步調用會導致程式很難調試。例如，當能調用了兩個包含非同步回調的 mutation 來改變狀態，怎麼知道什麼時候回調和哪個先回調呢？這就是為什麼要區分這兩個概念。在 Vuex 中，mutation 都是同步事務：

store.commit('increment')
// 任何由 "increment" 導致的狀態變更都應該在此刻完成。

　　Action類似於mutation，不同之處在於：

　　1、Action 提交的是 mutation，而不是直接變更狀態

　　2、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

　　實踐中，會經常用到 ES2015 的 參數解構 來簡化代碼（特別是需要調用 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 這個 JavaScript 新特性，可以像這樣組合 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 才會執行

module

　　由於使用單一狀態樹，應用的所有狀態會集中到一個比較大的對象。當應用變得非常複雜時，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 和 rootGetter 會作為第三和第四參數傳入 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) { ... }
    }
  }
}

【帶命名空間的綁定函數】

　　當使用 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',
    'some/nested/module/bar'
  ])
}

　　對於這種情況，可以將模塊的空間名稱字元串作為第一個參數傳遞給上述函數，這樣所有綁定都會自動將該模塊作為上下文。於是上面的例子可以簡化為

computed: {
  ...mapState('some/nested/module', {
    a: state => state.a,
    b: state => state.b
  })
},
methods: {
  ...mapActions('some/nested/module', [
    'foo',
    '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 方法註冊模塊：

// 註冊模塊 `myModule`
store.registerModule('myModule', {
  // ...
})
// 註冊嵌套模塊 `nested/myModule`
store.registerModule(['nested', 'myModule'], {
  // ...
})

　　之後就可以通過 store.state.myModule 和 store.state.nested.myModule 訪問模塊的狀態。

　　模塊動態註冊功能使得其他 Vue 插件可以通過在 store 中附加新模塊的方式來使用 Vuex 管理狀態。例如，vuex-router-sync 插件就是通過動態註冊模塊將 vue-router 和 vuex 結合在一起，實現應用的路由狀態管理。

　　也可以使用 store.unregisterModule(moduleName) 來動態卸載模塊。註意，不能使用此方法卸載靜態模塊（即創建 store 時聲明的模塊）

【模塊重用】

　　有時可能需要創建一個模塊的多個實例，例如：

　　1、創建多個 store，他們公用同一個模塊 (例如當 runInNewContext 選項是 false 或 'once' 時，為了在服務端渲染中避免有狀態的單例)

　　2、在一個 store 中多次註冊同一個模塊

　　如果使用一個純對象來聲明模塊的狀態，那麼這個狀態對象會通過引用被共用，導致狀態對象被修改時 store 或模塊間數據互相污染的問題。

　　實際上這和 Vue 組件內的 data 是同樣的問題。因此解決辦法也是相同的——使用一個函數來聲明模塊狀態（僅 2.3.0+ 支持）：

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

項目結構

　　Vuex 並不限制代碼結構。但是，它規定了一些需要遵守的規則：

　　1、應用層級的狀態應該集中到單個 store 對象中

　　2、提交 mutation 是更改狀態的唯一方法，並且這個過程是同步的

　　3、非同步邏輯都應該封裝到 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   # 產品模塊

插件

　　Vuex 的 store 接受 plugins 選項，這個選項暴露出每次 mutation 的鉤子。Vuex 插件就是一個函數，它接收 store 作為唯一參數：

const myPlugin = store => {
  // 當 store 初始化後調用
  store.subscribe((mutation, state) => {
    // 每次 mutation 之後調用
    // mutation 的格式為 { type, payload }
  })
}

　　然後像這樣使用：

const store = new Vuex.Store({
  // ...
  plugins: [myPlugin]
})

【在插件中提交Mutation】

　　在插件中不允許直接修改狀態——類似於組件，只能通過提交 mutation 來觸發變化。

　　通過提交 mutation，插件可以用來同步數據源到 store。例如，同步 websocket 數據源到 store（下麵是個大概例子，實際上 createPlugin 方法可以有更多選項來完成複雜任務）：

export default function createWebSocketPlugin (socket) {
  return store => {
    socket.on('data', data => {
      store.commit('receiveData', data)
    })
    store.subscribe(mutation => {
      if (mutation.type === 'UPDATE_DATA') {
        socket.emit('update', mutation.payload)
      }
    })
  }
}
const plugin = createWebSocketPlugin(socket)

const store = new Vuex.Store({
  state,
  mutations,
  plugins: [plugin]
})

【生成State快照】

　　有時候插件需要獲得狀態的“快照”，比較改變的前後狀態。想要實現這項功能，需要對狀態對象進行深拷貝：

const myPluginWithSnapshot = store => {
  let prevState = _.cloneDeep(store.state)
  store.subscribe((mutation, state) => {
    let nextState = _.cloneDeep(state)

    // 比較 prevState 和 nextState...

    // 保存狀態，用於下一次 mutation
    prevState = nextState
  })
}

　　生成狀態快照的插件應該只在開發階段使用，使用 webpack 或 Browserify，讓構建工具幫助處理：

const store = new Vuex.Store({
  // ...
  plugins: process.env.NODE_ENV !== 'production'
    ? [myPluginWithSnapshot]
    : []
})

　　上面插件會預設啟用。在發佈階段，需要使用 webpack 的 DefinePlugin 或者是 Browserify 的 envify 使 process.env.NODE_ENV !== 'production' 為 false

【內置Logger插件】

　　Vuex 自帶一個日誌插件用於一般的調試:

import createLogger from 'vuex/dist/logger'

const store = new Vuex.Store({
  plugins: [createLogger()]
})

　　createLogger 函數有幾個配置項：

const logger = createLogger({
  collapsed: false, // 自動展開記錄的 mutation
  filter (mutation, stateBefore, stateAfter) {
    // 若 mutation 需要被記錄，就讓它返回 true 即可
    // 順便，`mutation` 是個 { type, payload } 對象
    return mutation.type !== "aBlacklistedMutation"
  },
  transformer (state) {
    // 在開始記錄之前轉換狀態
    // 例如，只返回指定的子樹
    return state.subTree
  },
  mutationTransformer (mutation) {
    // mutation 按照 { type, payload } 格式記錄
    // 我們可以按任意方式格式化
    return mutation.type
  }
})

　　日誌插件還可以直接通過 <script> 標簽引入，它會提供全局方法 createVuexLogger。

　　要註意，logger 插件會生成狀態快照，所以僅在開發環境使用

嚴格模式

　　開啟嚴格模式，僅需在創建 store 的時候傳入 strict: true

const store = new Vuex.Store({
  // ...
  strict: true
})

　　在嚴格模式下，無論何時發生了狀態變更且不是由 mutation 函數引起的，將會拋出錯誤。這能保證所有的狀態變更都能被調試工具跟蹤到

【開發環境與發佈環境】

　　不要在發佈環境下啟用嚴格模式！嚴格模式會深度監測狀態樹來檢測不合規的狀態變更——請確保在發佈環境下關閉嚴格模式，以避免性能損失。

　　類似於插件，可以讓構建工具來處理這種情況：

const store = new Vuex.Store({
  // ...
  strict: process.env.NODE_ENV !== 'production'
})

表單處理

　　當在嚴格模式中使用 Vuex 時，在屬於 Vuex 的 state 上使用 v-model 會比較棘手：

<input v-model="obj.message">

　　假設這裡的 obj 是在計算屬性中返回的一個屬於 Vuex store 的對象，在用戶輸入時，v-model 會試圖直接修改