看完了官网vuex一头雾水的,比如vuex中的...mapState、countAlias: 'count'等。没看过官网也没事,希望对你们有帮助。
下文都是我的个人理解,官网的就引用了代码,也许存在着很多错误的描述或者理解,请各位请教,我会改正的。
这个坑之前就深挖了~现在是时候填了。
为什么要有vuex?
它是管理组件与组件通信的库。
子组件与父组件之间通信还是很方便的。但是如果是同级组件,或者是其它的复杂情况,比如:
- a.vue中的子组件想与b.vue中的子组件的通迅
- a.vue想与b.vue中的子组件的通迅
- a.vue中的子组件想与b.vue通迅
- a.vue的子组件的子组件想与b.vue的子组件通迅
- .....
就是为了解决了类似的问题~
我们把事件想简单点吧,如果你管理那么多组件(这个改变了那个的数据,那个改变了这个的数据,那个组件又多了点什么,这个又少了点什么),你会怎么做呢?就说想法,不用实现。
我的想法是:没有蛀牙 把整个应用的数据全部集中起来,谁想用作显示都无条件同意,而谁想改,改完了一定要通知所以用到这个数据显示的组件,还不是美滋滋?
vuex也是这个意思,它一共分为以下5个部分
- state 放数据的
- Getter 获取数据的
- Mutation 同步改变数据的
- Action 异步改变数据(利用Mutation实现)
- Module 可以把全局的数据仓库分为几个单独的模块,比如用户一个,文章一个。
1 state
1.1 state 定义
const store = new Vuex.Store({
state: {
count: 0
},
mutations: {
increment (state) {
state.count++
}
}
})
然后mutations先提一下怎么用吧(官网的例子,原汁原味 )
store.commit('increment')
console.log(store.state.count) // -> 1
然后要把这货放在组件里,如果放入父组件中,那么子组件也可以使用。通过 this.$store。
//普通的定义
const app = new Vue({
el: '#app',
// 把 store 对象提供给 “store” 选项,这可以把 store 的实例注入所有的子组件
store,
components: {XXX},
template: `XXX`
})
//*.vue
export default {
el: '#app',
store,
components: {XXX}
}
</script>
1.2 关于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
}
})
}
先说说mapState的作用,返回一个对象。
什么样的对象
{
cout: xxx //第一个
coutAlias:xxx //第二个
countPlusLocalState(state){xxxx}//第三个
}
我尽可能说详细一点,
export default {
computed: mapState({
/*根据箭头函数,生成的函数为
function(state){ return state.count},
所以count的值最后是state.count。count是个值。*/
count: state => state.count,
/* countAlias只是个名字,与上面的count没有一毛钱关系,我们的大前提,
是使用的vuex里的mapstate,所以,只要我们给一个store里的属性名,
mapstate就会把属性名对应的属性返回给我们,
并用我们提供的新名字。所以,countAliae就对应的state里的count。
*/
countAlias: 'count',
/*注意,我强调一下,如果你只给属性名,不给别名,那么就会按原属性名返回。 比如就是一个孤零零的 'a' 你调用的时候也要调a就完事了,上面的是调countAlias */
// 为了能够使用 `this` 获取局部状态,必须使用常规函数
/* 箭头函数基础,亲,如果你看不懂为什么要这样,请去参考下ES6的箭头函数 */
countPlusLocalState (state) {
return state.count + this.localCount
}
})
}
接下来讲mapState的第二个作用:偷懒。
突然出现了一个...mapState,这个...就是对象展开运算符,是ES6里的,可关键是为什么搞了这么一个另人费解的东西,有什么用呢?
答:并没有什么卵用还是有点用的,比如,你的compute属性里想用store里返回的东西,一共用5个!就可以用mapstate传5个属性名进去把五个搞出来再添加到compute里。
比如
computed:{
a1:function(){xxxxx}
}
可是你需要a2到a6,如果一个一个的写的话,就会这样:
computed:{
a1:function(){xxxxx},
a2:function(){return this.$store.a2},
a3:function(){return this.$store.a3},
.......
}
有了这个...
//注意,我再强调一下,如果你只给属性名,不给别名,
那么就会按原属性名返回。所以可以这么写:
compute:{
a1:function(){xxxxx},
...mapState({'a2','a3','a4','a5','a6'})
}
然后就全有了,和上面的作用一样,看吧,偷懒就完事了。
2 Getter
首先要审明下,做为读书人的我,也是会骂人的!!!!
之前很多程序员总是有些很奇怪的爱好,比如他母亲的Getter。这个Getter一见到名字就是想起了被java支配的恐惧,所以不说了 所以一定要好好理解!
vuex里的getter,是在store里的一个东西,为什么需要它呢?比如,
this.$store.state.todos.filter(todo => todo.done).length
这一句分别在十个函数里都出现了,就可以把他考虑做成一个getter函数。
把官网的例子搞了过来
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里的别的函数。(这里定义时不支持this直接拿)
getters: {
// ...
doneTodosCount: (state, getters) => {
return getters.doneTodos.length
}
}
store.getters.doneTodosCount // 得到1
在任何组件中(只要是上一级组件有store的)都可以使用:
computed: {
doneTodosCount () {
return this.$store.getters.doneTodosCount
}
}
getter 为什么好好的要返回一个函数?因为你返回了一个函数,还可以给函数传值,让他查些什么玩意,难道你们没有发现上面的例子都只是没有传我们自定义的参数的?现在发现了就行~
getters: {
// ...
getTodoById: (state) => (id) => {
return state.todos.find(todo => todo.id === id)
}
}
store.getters.getTodoById(2) // -> { id: 2, text: '...', done: false }
还有剩下的mapGetters,嘿嘿,和上面的mapState一样,返回属性的规则也一样:1 别名 2 偷懒
3 Mutation
如果 1与2都是获取数据展示的话,那么3与4就是修改完通知了~
搞一手官网:
更改 Vuex 的 store 中的状态的唯一方法是提交 mutation。Vuex 中的 mutation 非常类似于事件:每个 mutation 都有一个字符串的事件类型 (type) 和 一个 回调函数 (handler)。这个回调函数就是我们实际进行状态更改的地方,并且它会接受 state 作为第一个参数。
一个最基本的例子:
const store = new Vuex.Store({
state: {
count: 1
},
mutations: {
increment (state) {
// 变更状态
state.count++
}
}
})
//使用:
store.commit('increment')
//注意,这里的increment 只能通过store.commit('increment')才能触发
载荷,传事件的时候同时传个参数
既然能传一个字符串的事件类型的increment,那么一定会有别的更复杂的使用方法。妥妥的,commit里还能搞个别的东西传过去,这个就叫:载荷(payload)(我觉得可以理解成: 装备)
mutations: {
increment (state, payload) {
state.count += payload.amount
}
//提交的风格有两种(还是从官网上搞的)
//风格1:
store.commit('increment', {
amount: 10
})
//风格2:(个人觉得这个逼格更高一点点)
store.commit({
type: 'increment',
amount: 10
})
使用payload也是有条件的,
- 提前在你的 store 中初始化好所有所需属性
- 在对象上添加新属性时,应该更新这个属性,而不是再用一个新的对象
- 使用
Vue.set(obj, 'newProp', 123)
- 以新对象替换老对象。
state.obj = { ...state.obj, newProp: 123 }
- 使用
使用更短的名字使用Mutation&在组件中使用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')`*/
})
}
}
然后官网也提到了使用mutations的注意事项
不能使用异步函数(等待时间不能太长的函数,什么网络连接,读写文件,都不是异步函数)
如果你的程序中,有很多'increment'这种事件,推荐用常量保存后放在一个文件中,就像这样:
//文件名: mutation-types.js
export const GO_TO_PICS = 'GO_TO_PICS'
export const GO_TO_NEWS = 'GO_TO_NEWS'
export const GO_TO_WE = 'GO_TO_WE'
4 Action
离4这个标题不远处,你依稀可以看到,mutations不能使用异步函数,
Action就是提交异步事件的~
Action 提交的是 mutation,Action提交的是Action ,提交的是 mutation。重要的事件要说三遍。所以,Action是在mutation外又加了一层,看一个简单的例子。
const store = new Vuex.Store({
state: {
count: 0
},
mutations: {
increment (state) {
state.count++
}
},
actions: {
increment (context) {
context.commit('increment')
}
}
})
context是什么玩意?有什么用?
答:他是和 store 实例具有相同方法和属性的 context 对象。作用是[个人猜测,未验证]context对象作为store的辅助,也许是store的一些操作一定要通过context进行。
调用 context.commit 提交一个 mutation,或者通过 context.state 和 context.getters 来获取 state 和 getters。
少写一点(引用自网站,纯语法):
实践中,我们会经常用到 ES2015 的 参数解构 来简化代码(特别是我们需要调用
commit
很多次的时候):
actions: {
//这是ES6的语法
/*举个例子:{ blowUp } = { blowUp: 10 }; 结果:{blowUp:10}
从blowUp中取一个叫blowUp的属性。
参数本来是传过来的context,从context中取一个commit的东西,得到 { commit : context.commit };
挺另人头大的。
*/
increment ({ commit }) {
commit('increment')
}
}
使用action
store.dispatch('increment')
但是最主要是异步调用:
actions: {
incrementAsync ({ commit }) {
setTimeout(() => {
commit('increment')
}, 1000)
}
}
同样的支持载荷(payload,装备)
// 以载荷形式分发
store.dispatch('incrementAsync', {
amount: 10
})
// 以对象形式分发
store.dispatch({
type: 'incrementAsync',
amount: 10
})
官网上的一个更复杂的例子-购物车:
actions: {
// es6的语法,从context中取commit与state
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)
)
}
}
上面只是定义,还有在组件中使用action的方法,不要忘记这个。
关于mapActions,作用和定义你们懂得,下面用的官网的例子:
你在组件中使用
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,我们可以如下组合 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 才会执行。
5 Module
这个部分以后再说吧,想了解的可以去官网看看先。
网友评论