八、vuex

一、概念

Vuex官网

Vuex是一个专为Vue.js应用程序开发的状态管理模式

通俗讲就是把多个组件共享的变量全部存储在一个对象里面

二、使用方式

vuex不是vue内置的，但是是官方的

使用步骤

• 安装vuex

• 创建store对象管理数据

• 挂载store对象到vue实例

• 安装vuex

npm i -S vuex

• 创建store对象管理数据

  • 创建src/store目录，并在其中创建index.js文件用于导入并创建store对象

  • 编写src/store/index.js文件：

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

Vue.use(Vuex)

export default new Vuex.Store({
  state: {
  },
  mutations: {
  },
  actions: {
  },
  getters:{
  },
  modules: {
  }
})

• 挂载store对象到vue实例，main.js中编写如下代码

import Vue from 'vue'
import App from './App.vue'
import router from './router'
// 引入store
import store from './store'

Vue.config.productionTip = false

new Vue({
  router,
  // 使用store
  store,
  render: h => h(App)
}).$mount('#app')

三、核心概念

1、state

state提供唯一公共数据源，所有的共享数据都要统一放到state中进行存储

// 在组件中访问state数据的第一种方式
this.$store.state.全局数据名称

// 在组件中访问state数据的第二种方式，按需导入mapState函数
// 将全局函数映射为当前组件的计算属性，数据的使用方式如同在当前组件中使用自身的data数据一样
import { mapState } from 'vuex'
computed: {
    ...mapState(['count'])
}

2、mutations

mutations用于变更store中的数据

• 在Vuex中只能通过mutation变更store中的数据，不可以直接操作store中的数据

• 通过这种方式操作起来稍微繁琐一些，但是可以集中监控所有数据的变化

• 不要在mutation中写异步的代码

const store = new Vuex.Store({
  state: {
    count: 1
  },
  mutations: {
    // state是默认参数
    increment (state) {
      // 变更状态
      state.count++
    }
  }
})

// 组件中触发mutation的第一种方式
methods:{
    handle(){
        this.$store.commit('increment')
    }
}

// 组件中触发mutation的第二种方式
import { mapMutations } from 'vuex'

methods:{
    ...mapMutations(['increment','add']),
    handle1(){
        this.increment()
    },
    handle2(){
        this.add([arg1,...])
    }
}

• 可以向 store.commit 传入额外的参数，即 mutation 的 载荷（payload）：

// ...
mutations: {
  increment (state, n) {
    state.count += n
  }
}

store.commit('increment', 10)

3、actions

action类似于mutation

• action 提交的是 mutation，而不是直接变更状态

• action 可以包含任意异步操作

// store/index.js中声明action
const store = new Vuex.Store({
    // 省略其他代码
    mutations: {
        add(state){
            state.count++
        }
    },
    actions: {
        addAsync(context, [arg1,...]){
            setTimeout(() => {
                context.commit('add', [arg1,...])
            },1000)
        }
    }
})

组件中使用

// 组件中触发action的第一种方式
methods: {
    handle(){
        this.$store.dispach('addAsync', [arg1,...])
    }
}

// 组件中触发action的第二种方式
import { mapActions } from 'vuex'

export default {
  // ...
  methods: {
    ...mapActions([
      'addAsync' // 将 `this.increment()` 映射为 `this.$store.dispatch('increment')`
    ])
  }
}

4、getters

对store中已有的数据加工处理形成新的数据

• 对已有的数据进行加工，类似于Vue的计算属性，getter 的返回值会根据它的依赖被缓存起来

• store数据发生变化，则getter中的数据也会跟着变化

// 定义getter
....
getters: {
    showNum: state => {
        return '当前最新的数量是【' + state.count + '】'
    }
}

使用

// 在组件中访问getters数据的第一种方式
this.$store.getters.全局数据名称

// 在组件中访问getters数据的第二种方式，按需导入mapGetters函数
import {mapGetters} from 'vuex'
// 将全局函数映射为当前组件的计算属性
export default {
  // ...
  computed: {
    ...mapGetters(['showNum'])
  }
}

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

getters: {
  // ...
  getters: {
    doneTodos: state => {
      return state.todos.filter(todo => todo.done)
    }
  },
  doneTodosCount: (state, getters) => {
    return getters.doneTodos.length
  }
}

5、modules

• 当应用变得非常复杂时，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 的状态

• module中的mutations

const moduleA = {
  state: () => ({
    name: 'zhangsan'
  }),
  mutations: {
    updateName (state, payload) {
      // 这里的 `state` 对象是模块的局部状态
      state.name = payload
    }
  }
}

// 组件中使用
methods: {
  updateName() {
    this.$store.commit('updateName', 'lisi')
  }
}

module中的getters

const moduleA = {
  state: () => ({
    name: 'zhangsan'
  }),
  mutations: {
    updateName (state, payload) {
      // 这里的 `state` 对象是模块的局部状态
      state.name = payload
    }
  },
  getters: {
    fullName(state) {
      return state.name + '1111'   
    },
    // 第二个参数用来操作getters中的getter
    fullName2(state, getters) {
      return getters.fullName + '2222'   
    },
    // 第三个参数操作根state
    fullName3(state, getters, rootState) {
      return getters.fullName2 + rootState.count   
    }
  }
}

// 组件中使用
<div>{{$store.getters.fullName}}</div>
<div>{{$store.getters.fullName2}}</div>
<div>{{$store.getters.fullName3}}</div>
// 或者
methods: {
  updateName() {
    this.$store.getters.fullName()
  }
}

• module中的actions

const moduleA = {
  state: () => ({
    name: 'zhangsan'
  }),
  mutations: {
    updateName (state, payload) {
      // 这里的 `state` 对象是模块的局部状态
      state.name = payload
    }
  },
  actions: {
    aUpdateName() {
      setTimeout(() => {
          context.commit('updateName', 'wangwu')
        }, 1000)
    }
  }
}

// 组件内使用
methods: {
  asyncUpdateName() {
    this.$store.dispatch('aUpdateName')
  }
}