认识Vuex

什么是Vuex?
每一个 Vuex 应用的核心就是 store(仓库)。“store”基本上就是一个容器,它包含着你的应用中大部分的状态 (state)
可以把 store 通俗的理解为一个全局变量的仓库。但是和单纯的全局变量又有一些区别,主要体现在当 store 中的状态发生改变时,相应的 vue 组件也会得到高效更新。

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

  1. Vuex 的状态存储是响应式的。当 Vue 组件从 store 中读取状态的时候,若 store 中的状态发生变化,那么相应的组件也会相应地得到高效更新。

  2. 不能直接改变 store 中的状态。改变 store 中的状态的唯一途径就是显式地提交 (commit) mutation。这样使得我们可以方便地跟踪每一个状态的变化,从而让我们能够实现一些工具帮助我们更好地了解我们的应用。

    1. //直接修改store,不推荐
    2. setAuthor: function () {
    3. this.$store.state.author = this.inpuText
    4. }
  1. //在store.js中
  2. //其中第一个参数 state 就是 $store.state,第二个参数 msg 需要另外传入
  3. mutations: {
  4. setAuthor (state,value) {
  5. state.author = value
  6. }
  7. }
  1. //在组件中提交(commit) mutation
  2. this.$store.commit('setAuthor',this.inputValue)

最简单的 Store

创建store

  1. import Vue from 'vue'
  2. import Vuex from 'vuex'
  3. Vue.use(Vuex)
  4. const store = new Vuex.Store({
  5. state: {
  6. count: 0
  7. },
  8. mutations: {
  9. increment (state) {
  10. state.count++
  11. }
  12. }
  13. })

获取state

组件中调用 store 中的状态简单到仅需要在计算属性中返回即可

提交state更改

触发变化也仅仅是在组件的 methods 中提交 mutation。

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

核心概念

State

state 可以看成是 data 属性

如果用VUE文件来类比讲解store,state就相当于vue中的data属性,所有的状态或者说是数据都存储在这个state里面,我们在别的地方获取需要使用 this.$store.state.属性名称 来获取相应的值,并且我们可以通过 mutations 和 actions 来改变state的值,从而触发所有使用到state的地方刷新。state里可以存储各种数据类型,data里面可以用的数据类型,state里面同样可以使用。

  1. export default new Vuex.Store({
  2. state: {
  3. count: 0
  4. },
  5. mutations: {
  6. },
  7. actions: {
  8. },
  9. modules: {
  10. }
  11. })

获取State

那么我们如何在 Vue 组件中展示状态呢?由于 Vuex 的状态存储是响应式的,从 store 实例中读取状态最简单的方法就是在计算属性中返回某个状态

  1. computed: {
  2. count () {
  3. return this.$store.state.count
  4. }
  5. }

mapState 辅助函数

https://mp.weixin.qq.com/s/W9A5fwZvaAHX5C0sFJD53A

当一个组件需要获取多个状态的时候,将这些状态都声明为计算属性会有些重复和冗余。为了解决这个问题,我们可以使用 **mapState** 辅助函数帮助我们生成计算属性,让你少按几次键:

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

当映射的计算属性的名称与 state 的子节点名称相同时,我们也可以给 mapState 传一个字符串数组。

  1. computed: mapState([
  2. // 映射 this.count 为 store.state.count
  3. 'count'
  4. ])


对象展开运算符

mapState 函数返回的是一个对象。我们如何将它与局部计算属性混合使用呢?通常,我们需要使用一个工具函数将多个对象合并为一个,以使我们可以将最终对象传给 computed 属性。但是自从有了对象展开运算符 (opens new window),我们可以极大地简化写法:

  1. computed: {
  2. localComputed () { /* ... */ },
  3. // 使用对象展开运算符将此对象混入到外部对象中
  4. ...mapState({
  5. // ...
  6. })
  7. }

Getters

getters 可以看成是 store 的 computed 计算属性

有时候我们需要从 store 中的 state 中派生出一些状态,例如对列表进行过滤并计数:

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

如果有多个组件需要用到此属性,我们要么复制这个函数,或者抽取到一个共享函数然后在多处导入它——无论哪种方式都不是很理想。

Vuex 允许我们在 store 中定义“getter”(可以认为是 store 的计算属性)。就像计算属性一样,getter 的返回值会根据它的依赖被缓存起来,且只有当它的依赖值发生了改变才会被重新计算。

Getter 接受 state 作为其第一个参数:

  1. const store = new Vuex.Store({
  2. state: {
  3. todos: [
  4. { id: 1, text: '...', done: true },
  5. { id: 2, text: '...', done: false }
  6. ]
  7. },
  8. getters: {
  9. doneTodos: state => {
  10. return state.todos.filter(todo => todo.done)
  11. }
  12. }
  13. })

通过属性访问 getters

Getter 会暴露为 store.getters 对象,你可以以属性的形式访问这些值:

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

Getter 也可以接受其他 getter 作为第二个参数

  1. getters: {
  2. // ...
  3. doneTodosCount: (state, getters) => {
  4. return getters.doneTodos.length
  5. }
  6. }
  1. store.getters.doneTodosCount // -> 1

我们可以很容易地在任何组件中使用它:

  1. computed: {
  2. doneTodosCount () {
  3. return this.$store.getters.doneTodosCount
  4. }
  5. }

注意,getter 在通过属性访问时是作为 Vue 的响应式系统的一部分缓存其中的。

通过方法访问 getters

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

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

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

mapGetters 辅助函数

mapGetters 辅助函数仅仅是将 store 中的 getter 映射到局部计算属性:

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

如果你想将一个 getter 属性另取一个名字,使用对象形式:

  1. ...mapGetters({
  2. // 把 `this.doneCount` 映射为 `this.$store.getters.doneTodosCount`
  3. doneCount: 'doneTodosCount'
  4. })

Mutation

mutation 非常类似于 methods 事件

更改 Vuex 的 store 中的状态的唯一方法是提交 mutation。Vuex 中的 mutation 非常类似于事件:每个 mutation 都有一个字符串的 事件类型 (type) 和 一个 回调函数 (handler)。这个回调函数就是我们实际进行状态更改的地方,并且它会接受 state 作为第一个参数:

  1. const store = new Vuex.Store({
  2. state: {
  3. count: 1
  4. },
  5. mutations: {
  6. increment (state) {
  7. // 变更状态
  8. state.count++
  9. }
  10. }
  11. })

你不能直接调用一个 mutation handler。这个选项更像是事件注册:“当触发一个类型为 increment 的 mutation 时,调用此函数。”要唤醒一个 mutation handler,你需要以相应的 type 调用 store.commit 方法:

  1. store.commit('increment')

提交载荷(Payload)

你可以向 store.commit 传入额外的参数,即 mutation 的 载荷(payload)

  1. // ...
  2. mutations: {
  3. increment (state, n) {
  4. state.count += n
  5. }
  6. }
  1. store.commit('increment', 10)

在大多数情况下,载荷应该是一个对象,这样可以包含多个字段并且记录的 mutation 会更易读:

  1. // ...
  2. mutations: {
  3. increment (state, payload) {
  4. state.count += payload.amount
  5. }
  6. }
  1. store.commit('increment', {
  2. amount: 10
  3. })

对象风格的提交方式

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

  1. store.commit({
  2. type: 'increment',
  3. amount: 10
  4. })

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

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

#Mutation 需遵守 Vue 的响应规则

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

  1. 最好提前在你的 store 中初始化好所有所需属性。
  2. 当需要在对象上添加新属性时,你应该
  • 使用 Vue.set(obj, 'newProp', 123), 或者
  • 以新对象替换老对象。例如,利用对象展开运算符 (opens new window)我们可以这样写:
    1. state.obj = { ...state.obj, newProp: 123 }

    #使用常量替代 Mutation 事件类型

    使用常量替代 mutation 事件类型在各种 Flux 实现中是很常见的模式。这样可以使 linter 之类的工具发挥作用,同时把这些常量放在单独的文件中可以让你的代码合作者对整个 app 包含的 mutation 一目了然:
    1. // mutation-types.js
    2. export const SOME_MUTATION = 'SOME_MUTATION'
    1. // store.js
    2. import Vuex from 'vuex'
    3. import { SOME_MUTATION } from './mutation-types'
    4. const store = new Vuex.Store({
    5. state: { ... },
    6. mutations: {
    7. // 我们可以使用 ES2015 风格的计算属性命名功能来使用一个常量作为函数名
    8. [SOME_MUTATION] (state) {
    9. // mutate state
    10. }
    11. }
    12. })
    用不用常量取决于你——在需要多人协作的大型项目中,这会很有帮助。但如果你不喜欢,你完全可以不这样做。

    #Mutation 必须是同步函数

    一条重要的原则就是要记住 mutation 必须是同步函数。为什么?请参考下面的例子:
    1. mutations: {
    2. someMutation (state) {
    3. api.callAsyncMethod(() => {
    4. state.count++
    5. })
    6. }
    7. }
    现在想象,我们正在 debug 一个 app 并且观察 devtool 中的 mutation 日志。每一条 mutation 被记录,devtools 都需要捕捉到前一状态和后一状态的快照。然而,在上面的例子中 mutation 中的异步函数中的回调让这不可能完成:因为当 mutation 触发的时候,回调函数还没有被调用,devtools 不知道什么时候回调函数实际上被调用——实质上任何在回调函数中进行的状态的改变都是不可追踪的。

    #在组件中提交 Mutation

    你可以在组件中使用 this.$store.commit('xxx') 提交 mutation,或者使用 mapMutations 辅助函数将组件中的 methods 映射为 store.commit 调用(需要在根节点注入 store)。
    1. import { mapMutations } from 'vuex'
    2. export default {
    3. // ...
    4. methods: {
    5. ...mapMutations([
    6. 'increment', // 将 `this.increment()` 映射为 `this.$store.commit('increment')`
    7. // `mapMutations` 也支持载荷:
    8. 'incrementBy' // 将 `this.incrementBy(amount)` 映射为 `this.$store.commit('incrementBy', amount)`
    9. ]),
    10. ...mapMutations({
    11. add: 'increment' // 将 `this.add()` 映射为 `this.$store.commit('increment')`
    12. })
    13. }
    14. }

    #下一步:Action

    在 mutation 中混合异步调用会导致你的程序很难调试。例如,当你调用了两个包含异步回调的 mutation 来改变状态,你怎么知道什么时候回调和哪个先回调呢?这就是为什么我们要区分这两个概念。在 Vuex 中,mutation 都是同步事务
    1. store.commit('increment')
    2. // 任何由 "increment" 导致的状态变更都应该在此刻完成。
    为了处理异步操作,让我们来看一看 Action

    Actions

    异步操作

    参考

    https://vuex.vuejs.org/zh/