vuex

 

vuex的使用

State

state 即状态,就是所有组件可以共享的数据, 它是响应式的,只要它里面的数据发生改变,所有应用到他的组件都会跟着改变。 当 store 注册到vue对象中的时候,即

new Vue({
    el: '#app',
    store,
    ... 
})

此时, 可以通过 this.$store.state.XXX来引用,但并不推荐,因为这样写很难去追踪状态的变化

mapState 辅助函数

当我们用到vuex中存储的公共数据, 且此时是直接使用,而不需任何操作的时候,可以用如下代码,必须写在computed中

computed: {
    ...mapState({
        // 直接获取vuex中的数据
        xxx: state => state.xxx
        // 传字符串参数 'xxx' 等同于 `state => state.xxx`
        // xxxAlias 为xxx的别名
        xxxAlias: 'xxx',
        // 为了能同时操作vuex和本组件的数据,当使用到this的时候,必须使用常规函数
        xxxPlugsLocalState () {
           return state.xxx + this.zzz
    	}
    })
    // 当映射到计算属性的名称与vuex中的数据相同时,可以给mapState传递一个字符串数组
    ...mapState([
		xxx
    ])
}

Getter

getter的功能和其语义是一样的, 即从vuex中取数据

当然,它也可以这么用,即 this.$store.getter.XXX 此时的XXX在vuex中是个函数

getter在vuex 中的写法

const store = new Vuex.Store({
    state: {
        todoList: [
            {id: 1, text: '...', done: true},
            {id: 2, text: '...', done: false},
            {id: 1, text: '...', done: true},
        ]
    }
    getters: {
        todoDone: state => {
            return state.todoList.filter((todo) => todo.done)
        },
        // Getter 也可以接受其他 getter 作为第二个参数
        todoDoneCount: (state, getters) => {
            return getters.todoDone.length        
        },
        // getter函数也可以接受参数,用来筛选store中的数据很有效
        getTodoById: state => (id) => {
            return state.todoList.find(todo => todo.id === id)
        }
    }
})
mapGetters 辅助函数

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

improt { mapGetters } from 'vuex'

export default {
    ...
    computed: {
        ...mapGetters([
            'todoDone',
            'todoDoneCount',
            'getTodoById'
        ])
        // 如果你想将一个 getter 属性另取一个名字,使用对象形式:
        ...mapGetters({
            doneCount: 'todoDoneCount'
        })
    }
}

写到这里,我有一个疑问,那就是为什么mapState和mapGetters都可以从vuex中取数据,那它俩有什么区别呢?

我自己的理解如下: mapState只能取 state 中的原始数据,而mapGetters则可以先对state中的数据进行某些加工, getters类似store中的计算属性,他也可以对数据进行缓存,只有当数据发生变化的时候才会重新计算。当getters通过方法访问时,每次都会去调用,而不会缓存结果

Mutation

更改vuex store中状态的唯一方法就是提交mutation

用法

const store = new Vuex.Store({
    state: {
        count: 0
    },
    mutation: {
        increment (state) {
            state.count++
        }
    }
})

当需要改变state状态的时候,不能直接调用mutation中的函数,而必须向下面这样

store.commit('imcrement')

当然,你也可以给increment传递参数,即Mutation的荷载(payload)

...
mutation: {
    // 参数既可以是普通变量,也可以是对象
    increment (state, obj) {
        state.count += obj.name
    }
}
...
--------------------------------------------
// 用法
let obj = {
    name: 'simple'
}
store.commit('increment', obj)

// 对象形式的提交
store.commit({
    type: 'increment',
    age: 'simple'
})
在组件中提交Mutation

首先,声明mutation中的函数必须是同步函数。

this.$store.commit('xxx')
mapMutations 辅助函数
import { mapMutations } from 'vuex'
export default {
    methods: {
        // 注意此时的mapMutations是写在method中的
        ...mapMutations({
            add: 'increment'
        }),
        ...mapMutations([
            'increment'
        ])
    }
}

Actions

actions 和mutations差不多,只不过actions中提交的mutations,而不是直接变更状态,还有actions可以处理异步任务。

const store = new Vuex.Store({
    state: {
        count: 0
    },
    mutations: {
        increment (state) {
            state.count++
        }
    },
    actions: {
        increment (context) {
            // context和store拥有相同的属性和方法
            context.commit('increment')
        }
        // 一般这么写简化代码
        increment ({commit}) {
            commit('increment')
        }
    }
})
在组件中分发actions

this.$store.dispatch('xxx')

mapActions 辅助函数
import { mapActions } from 'vuex'
export default {
    methods: {
        ...mapActions({
            add: 'increment'
        }),
        ...mapActions(['increment'])
    }
}
组合Actions

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