Detailed introduction to Chinese documents of vuex-JS Tutorial-php.cn

Vuex is a state management model specially developed for Vue.js applications. It centrally stores and manages the state of all components of the application. This article introduces you to the vuex usage documentation. Friends who need it can refer to it

What is Vuex?

Vuex is a state management pattern developed specifically for Vue.js applications. It uses centralized storage to manage the state of all components of the application, and uses corresponding rules to ensure that the state changes in a predictable way. Vuex is also integrated into Vue's official debugging tool devtools extension, providing advanced debugging functions such as zero-configuration time-travel debugging, status snapshot import and export, etc.

Installation

Direct download CDN reference

1 2	`<script src="/path/to/vue.js"></script>` `<script src="/path/to/vuex.js"></script>`

Copy after login

npm　

1	`npm install vuex --save`

Copy after login

In a modular packaging system, you must install Vuex explicitly via Vue.use().

import Vue from &#39;vue&#39;
　　import Vuex from &#39;vuex&#39;
　　Vue.use(Vuex)

Copy after login

Vuex is a state management model developed specifically for Vue.js applications. It centrally stores and manages the state of all components of the application.

State management includes the following partial states:

State drives the data source of the application;

View maps state to views in a life-like manner.

　　actions Respond to state changes caused by user input on the view.

Help us manage shared status for medium and large single-page applications.

　state

　　 Single state tree, Vuex uses a single state tree to contain all application-level states with one object.

　　Get the Vuex state in the Vue component.

Since Vuex’s state storage is reactive, the easiest way to read the state from the store instance is to return a certain state in a computed property.

Create a Counter component

const Counter = {
　　　　　　　template: &#39;<p>{{ count }}</p>&#39;
　　　　　　　computed: {
　　　　　　　　　count ()｛
　　　　　　　　　　　return store.state.count
　　　　　　　　　｝
　　　　　　　}
　　　　　}

Copy after login

Every time store.state.count changes, the calculated properties will be re-obtained and the relevant DOM will be updated

Vuex passes the store option, provides a mechanism to "inject" state from the root component into each sub-component (requires calling Vue.use(Vuex)): 　　

const app = new Vue({
　　　　　　　el:&#39;#app&#39;,
　　　　　　　// 把 store 对象提供给 “store” 选项，这可以把 store 的实例注入所 有的子组件
　　　　　　　store,
　　　　　　　components: {Counter},
　　　　　template: &#39;
　　　　　　　<p class="app">
　　　　　　　　　<counter></counter>
　　　　　　　</p>
　　　　　　　&#39;
　　　　　})

Copy after login

By registering the store option in the root instance, the store The instance will be registered to all sub-components under the component, and the sub-components can be accessed through this.$store. Update the implementation of counter: 　　

const Counter = {
　　　　　　　template : &#39;<p>{{ count }}</p>&#39;,
　　　　　　　computed: {
　　　　　　　　　count this.$store.state.count
　　　　　　　　　}
　　　　　}

Copy after login

mapState auxiliary function　　　　　　　　　　　

// 在单独构建的版本中辅助函数为 Vuex.mapState
　　　　　　import { mapState } from &#39;vuex&#39;
　　　　　　　　export default {
　　　　　　　　　　computed: mapState({
　　　　　　　　　　　　// 箭头函数可以使代码更简洁
　　　　　　　　　　　　　　count: state => state.count,
　　　　　　　　　　　　// 传字符串参数 ‘count&#39; 等同于 ‘state => state.count&#39;
　　　　　　　　　　　　　　countAlias: &#39;count&#39;,
　　　　　　　　　　　　// 为了能够使用 ‘this&#39; 获取局部状态，必须使用常规函数
　　　　　　　　　　　　　　countPlusLocalState(state) {
　　　　　　　　　　　　　　　　　　return state.count + this.localCount
　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　})
　　　　　　　　　}

Copy after login

mapState Auxiliary Function

computed: mapState([
　　　　　　　　　　　　// 映射 this.count 为 store.state.count
　　　　　　　　　　　　&#39;count&#39;
　　　　　　　　　　])

Copy after login

mapState Auxiliary Function

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

Copy after login

mapState Auxiliary Function

Attributes will be somewhat redundant.

In order to solve this problem, we can use the mapState helper function to help us generate calculated properties.

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

Copy after login

When the name of the mapped calculated attribute is the same as the name of the child node of state, we can also pass a string array to mapState.　　　　　

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

Copy after login

　　Components still retain local state.

Getters

Sometimes we need to derive some state from the state in the store, such as filtering and calculating the list.

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

Copy after login

Vuex allows us to define getters in the store (which can be considered as computed properties of store)

Getters accept state as its first parameter.

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

Copy after login

Getters will be exposed as store.getters objects:

import {mapGetter} form &#39;vuex&#39;
　　　　　　export default {
　　　　　　　　computed: {
　　　　　　　　　　// 使用对象展开运算符将 getters 混入
　　　　　　　　　　...mapGetters([
　　　　　　　　　　　　　　‘doneTodosCount&#39;,
　　　　　　　　　　　　　　&#39;anotherGetter&#39;
　　　　　　　　　　　　])
　　　　　　　　　　}
　　　　　　　　}

Copy after login

Getters can also accept other getters as second parameters: ###

mapGetters({
 　　　　　　　　// 映射 this.doneCount 为 store.getters.doneTodosCount
　　　　　　　　　　doneCount: &#39;doneTodosCount&#39;
　　　　　　})

Copy after login

### We can easily add them to any component Used in ###

const store = new Vue.Store({
　　　　　　　　state: {
　　　　　　　　　　　　count: 1
　　　　　　　　},
　　　　　　mutations: {
　　　　　　　　　　inctement (state) {
　　　　　　　　　　state.count++
　　　　　　　　}
　　　　　　}
　　　　})

Copy after login

###　　　mapGetters auxiliary function######　　　mapGetters auxiliary function is just the getters in the store mapped to local calculated properties. ###

1	`store.commit('increment')`

Copy after login

### 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 around forwardover through to another name for a getter property, using object properties###

mutations: {
　　　　　　　　　　increment (state, n) {
　　　　　　　　　　state.count += n
　　　　　　　　}
　　　　　　}
　　　　　　store.commit(&#39;increment&#39;, 10)

Copy after login

###　　　　 The only way to change the state in the Vuex store is to submit a mutation Vuex The mutations in ###### are very similar to events. Each mutation has a string event type and callback function. This callback function is where we actually make the state changes. And it will accept state as the first parameter.　　###

mutations: {
　　　　　　increment (state,payload) {
　　　　　　　　state.count += payload.amount
　　　　　　　　}
　　　　　　}
　　　　　　store.commit(&#39;increment&#39;, {
　　　　　　　　amount:10
　　　　})

Copy after login

### 　This function is called when a mutation of type increment is triggered. "To wake up a mutation handler, you need to call the store.commit method with the corresponding type. ###

store.commit({
　　　　　　　type: &#39;increment&#39;,
　　　　　　　amount:10
　　　　　})

Copy after login

### Submit the payload###### You can pass it to store.commit Additional parameters, the payload of the mutation: ###

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

Copy after login

### In most cases, the payload should be an object, which can contain multiple fields and record the mutation more readable. ###

mutations: {
　　　　　　increment (state,payload) {
　　　　　　　　state.count += payload.amount
　　　　　　　　}
　　　　　　}
　　　　　　store.commit(&#39;increment&#39;, {
　　　　　　　　amount:10
　　　　})

Copy after login

　　对象风格的提交方式

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

store.commit({
　　　　　　　type: &#39;increment&#39;,
　　　　　　　amount:10
　　　　　})

Copy after login

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

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

Copy after login

　　Mutations 需遵守vue 的响应规则

　　　　既然Vuex的store 中的状态是响应式的，那么当我们变更状态时，监视状态的vue更新，这也意味值Vue 中的mutation 也需要与使用 Vue 一样遵守一些注意事项。

　　　　　　1. 最好提前在你的store 中初始化好所有的所需要的属性。

　　　　　　2.当需要在对象上提交新属性时，你应该使用　　　　　　　　

1	`Vue.set(obj, 'newProp', 123)`

Copy after login

　　　　　　使用新对象代替老对象 state.obj= {...state.obj ,newProp: 123}

　　　　　　使用常量替代 Mutation 事件类型

　　　　　　使用常量替代 mutation 事件类型在各种 Flux 实现中是很常见的模式　　　　　

export const SOME_MUTATION = &#39;SOME_MUTATION&#39;;
　　　　　　import Vuex from &#39;vuex&#39;
　　　　　　import {SOME_MUTATION } from &#39;./mutation-types&#39;
　　　　　　const store = new Vuex.Store({
　　　　　　　　　　state： {...}
　　　　　　　　　　mutations: {
　　　　　　　　　　　　// 我们可以使用 ES2015 风格的计算属性命名功能来使用一个常量作为函数名
　　　　　　　　　　　　[SOME_MUTATION] (state) {
　　　　　　　　　　　　// mutate state
　　　　　　　　　　　　}
　　　　　　　　　　}
　　　　　　})

Copy after login

mutation 必须是同步函数

　　　　一条重要的原则是记住 mutation 必须是同步函数。　　　　　　　

mutations: {
　　　　　　　　　someMutation (state) {
　　　　　　　　　　　api.callAsyncMethod(() => {
　　　　　　　　　　　　　　　state.count++
　　　　　　　　　　　})
　　　　　　　　　}
　　　　　　　}

Copy after login

在组件中提交 Mutations

　　　　你可以在组件中使用 this.$store.commit('xxx') 提交 mutation,或者使使用 mapMutations辅助函数将组建中的methods 映射为 store.commit 调用 (需要在根节点注入 store)　　　　

import {mapMutations} from 'vuex'
　　　　　　expor default {
　　　　　　　　methods: {
　　　　　　　　　　mapMutations([
　　　　　　　　　　　　　　methods: {
　　　　　　　　　　　　　　　　mapMutations([
　　　　　　　　　　　　　　　　　　'increment' // 映射 this.increment() 为 this.$store.commit(&#39;increment&#39;)
　　　　　　　　　　]),
　　　　　　　　mapMutations({
　　　　　　　　　　　　　　add: 'increment' // 映射 this.add() 为 this.$store.commit(&#39;increment&#39;)
　　　　　　　　　　})
　　　　　　　　}
　　　　　　])
　　　　　　}
　　　　}

Copy after login

Actions

　　　　在mutation 中混异步调用会导致你的程序很难调试。

Actions

　　　　Action 类似于 mutation,不同在于。

　　　　Action 提交的是 mutation ,而不是直接变更状态。

　　　　Action 可以包含任意异步操作。

　　　　注册一个简单的 action　　　　

const store = new Vuex.Store({
　　　　　　state: {
　　　　　　　　　　count：0
　　　　　　}，
　　　　mutations: {
　　　　　　increment (state) {
　　　　　　　　state.count++
　　　　　　}
　　　　},
　　　　actions: {
　　　　　　　　increment (context){
　　　　　　　　　　context.commit(&#39;increment&#39;)
　　　　　　　　　　}
　　　　　　　　}
　　　　})

Copy after login

Action 函数接受一个与store 实例具有相同方法和属性的context 对象，因此你可以调用 context.commit 提交一个mutation,或者通过 context.state 和context.getters 来获取 state 和 getters 当我们在之后介绍到Modules时，你就知道 context 对象为什么不是store 实例本身了。　　　

actions: {
　　　　　　increment({commit}){
　　　　　　　　commit(&#39;increment&#39;)
　　　　　　}
　　　　}

Copy after login

分发 Action

　　　　Action 通过 store.dispatch 方法触发：　　　　

1	`store.dispatch('increment')`

Copy after login

　　　　我们可以在 action 内部执行异步操作。　　　

actions: {
　　　　　incrementAsync({commit}){
　　　　　　　setTimeout(() => {
　　　　　　　　　commit(&#39;increment&#39;)
　　　　　　　},1000)
　　　　　　　}
　　　　　}

Copy after login

　　Actions 支持同样的载荷方式和对象方式进行分发　　　　

// 以载荷形式分发
　　　store.dispatch(&#39;incrementAsync&#39;,{
　　　　　amount:10
　　　})
　　　// 以对象形式分发
　　　　　store.dispatch({
　　　　　　　type: &#39;incrementAsync&#39;,
　　　　　　　amount:10
　　　　　})

Copy after login

在组件中分发 Action

　　　　你在组件中使用 this.$store.dispatch('xxx') 分发 action,或者使用map Actions辅助函数将组件的methods 映射为store.dispatch 调用　　　

import {mapActions } from 'vuex'
　　　　　　export default{
　　　　　　　　methods:([
　　　　　　　　　　'increment' // 映射 this.increment() 为 this.$store.dispatch(&#39;increment&#39;)
　　　　　　　　])
　　　　　　mapActions({
　　　　　　　　　　add: 'inctement' // 映射 this.add() 为 this.$store.dispatch(&#39;increment&#39;)
　　　　　　　　})
　　　　　　}

Copy after login

组合 Actions

　　　　Action 通常是异步的，那么如何知道 action 什么时候结束。

　　　　你需要明白 store.dispatch 可以处理被处触发的action 的回调函数返回的Promise并且 store.dispatch 仍旧返回Promise　　　

actions: {
　　　　　　　　actionA({commit}){
　　　　　　　　return new Promise((resolve)=>{
　　　　　　　　　　　　setTimeout (() => {
　　　　　　　　　　　　　　commit(&#39;someMutation&#39;)
　　　　　　　　　　　　　　resolve()
　　　　　　　　　　　　},1000)
　　　　　　　　　　})
　　　　　　　　}
　　　　　　}

Copy after login

　　现在你可以　　　　　

store.dispatch(&#39;actionA&#39;).then(()=>{
　　　　　　　　//...
　　　　　　})

Copy after login

　　在另一个 action 中也可以　　

actions: {
　　　　　　actionB({dispath,commit}){
　　　　　　　　return dispatch(&#39;actionA&#39;).then(() => { 
　　　　　　　　commit(&#39;someOtherMutation&#39;)
　　　　　　})
　　　　}
　　　　}

Copy after login

　　我们利用async/ await　　　

// 假设 getData() 和 getOther() 返回的是一个 Promis
　　　　actions:{
　　　　　　　　async actionA ({commit}){
　　　　　　　　　　commit(&#39;gotData&#39;,await getData())
　　　　　　　　},
　　　　　　　　async actionB({dispatch,commit}){
　　　　　　　　　　await dispatch(&#39;actionA&#39;) // 等待 actionA 完成
　　　　　　　　　　commit(&#39;goOtherData&#39;, await getOtherData())
　　　　　　　　}
　　　　　　}

Copy after login

　　　　Modules

　　　　　　使用单一状态树，当应用变的很大的时候，store 对象会变的臃肿不堪。

　　　　　　Vuex 允许我们将store 分割到模块。每一个模块都有自己的state, mutation,action, getters, 甚至是嵌套子模块从上到下进行类似的分割。　　　　　

const moduleA = {
　　　　　　　　　　state: {...},
　　　　　　　　mutations: {...}
　　　　　　　　actions: {...}
　　　　　　　　getters:{...}
　　　　　　　　}
　　　　const moduleA = {
　　　　　　　　state: {...},
　　　　　　　　mutations: {...}
　　　　　　　　actions: {...}
　　　　　　}
　　　　const store = new Vuex.Store({
　　　　　　modules: {
　　　　　　　　　　a:moduleA,
　　　　　　　　　　b:moduleB
　　　　　　　　}
　　　　　　})
　　　　store.state.a // -> moduleA 的状态
　　　　store.state.b // -> moduleB 的状态

Copy after login

模块的局部状态

　　　　对于模块内部的 mutation 和 getter, 接收的第一个参数是模块的局部状态。　　

const moduleA = {
　　　　　　　　　state: {count:0},
　　　　　　　　　mutations: {
　　　　　　　　　　　increment (state) {
　　　　　　　　　　　　　　　// state 模块的局部状态
　　　　　　　　　　　　　　　state.count++
　　　　　　　　　　　}
　　　　　　　　　},
　　　　　getters: {
　　　　　　　doubleCount (state) {
　　　　　　　return state.count * 2
　　　　　　　}
　　　　　}
　　　}

Copy after login

　　同样对于模块内部的action, context.state 是局部状态，根节点的窗台石context.rootState:　　　　

const moduleA = {
　　　　　　　　　　actions: {
　　　　　　　　　　incrementIfOddOnRootSum ({state, commit ,rootState}) {
　　　　　　　　　　　　if((state.count + rootState.count) %2 ===1){
　　　　　　　　　　　　　　　　commit(&#39;increment&#39;)
　　　　　　　　　　}
　　　　　　　　　}
　　　　　　　　}
　　　　　　}

Copy after login

对于模块内部的getter,跟节点状态会作为第三个参数：　　　　　

const moduleA = {
　　　　　　　　　　getters: {
　　　　　　　　　　　　getters: {
　　　　　　　　　　　　　　sumWithRootCount (state,getters,rootState) {
　　　　　　　　　　　　　　　　　　　　　　return state.count + rootState.count
　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　}
　　　　　　　　　　}
　　　　　　　　}

Copy after login

命名空间

　　　　模块内部的action, mutation , 和 getter 现在仍然注册在全局命名空间这样保证了多个模块能够响应同一 mutation 或 action. 也可以通过添加前缀或者后缀的

　　　　　　方式隔离各个模块，以免冲突。　　　　　

// 定义 getter, action , 和 mutation 的名称为常量，以模块名 ‘todo&#39; 为前缀。
　　　　　　　　export const DONE_COUNT = &#39;todos/DONE_COUNT&#39;
　　　　　　　　export const FETCH_ALL = &#39;todos/FETCH_ALL&#39;
　　　　　　　　export const TOGGLE_DONE = &#39;todos/TOGGLE_DONE&#39;
 　　　　　　　　 import * as types form &#39;../types&#39;
　　　　// 使用添加了解前缀的名称定义， getter, action 和 mutation
 　　　　const todosModule = {
　　　　　　　　state : {todo: []},
　　　　　　　　getters: {
　　　　　　　　　　[type.DONE_COUNT] (state) {
　　　　　　　　　　}
　　　　　　}
　　　　actions: {
　　　　　　　　[types.FETCH_ALL] (context,payload) {
　　　　　　　}
　　　　　　},
　　　　mutations: {
　　　　　　　　[type.TOGGLE_DONE] (state, payload)
　　　　　　}
　　　　}

Copy after login

模块动态注册

　　　　在store 创建之后，你可以使用 store.registerModule 方法注册模块。　　　　　

1	`store.registerModule('myModule',{})`

Copy after login

　　　　　　模块的状态将是 store.state.myModule.

　　　　　　模块动态注册功能可以使让其他Vue 插件为了应用的store 附加新模块

　　　　　　以此来分割Vuex 的状态管理。

　　　　项目结构

　　　　　　Vuex 并不限制你的代码结构。但是它规定了一些需要遵守的规则：

　　　　　　　　1.应用层级的状态应该集中到单个store 对象中。

　　　　　　　　2.提交 mutation 是更改状态的唯一方法，并且这个过程是同步的。

　　　　　　　　3.异步逻辑应该封装到action 里面。

　　　　　　　　　　只要你遵守以上规则，如何组织代码随你便。如果你的 store 文件太大，只需将 action、mutation、和 getters 分割到单独的文件对于大型应用，我们会希望把 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 # 产品模块

Copy after login

上面是我整理给大家的，希望今后会对大家有帮助。

使用vue2.0如何实现前端星星评分功能组件

有关Vue打包map文件的问题

使用Node.js实现压缩和解压缩功能

The above is the detailed content of Detailed introduction to Chinese documents of vuex. For more information, please follow other related articles on the PHP Chinese website!