异步操作和变更

异步操作和变异对于 Vuex 中的状态管理至关重要，尤其是在处理数据获取、API 调用或任何需要时间完成的操作时。正确处理异步操作可以确保应用程序的状态保持一致和可预测。本章将深入探讨异步操作的复杂性、它们与变异的关系以及有效管理它们的最佳实践。

理解异步操作

Vuex 中的操作是提交mutations的函数。它们是 Vuex 存储中更改状态的唯一方式。操作可以包含任意的异步操作。这是操作和变异之间的一个关键区别：mutations必须是同步的。

为什么需要异步操作？

考虑一个需要先从 API 获取数据再更新状态的场景。这个过程本质上就是异步的。你不会希望在等待 API 响应时阻塞主线程。动作允许你在不冻结 UI 的情况下执行这些异步操作。

示例： 从 API 获取用户数据。

// store.js
import Vue from 'vue'
import Vuex from 'vuex'
import axios from 'axios' // Assuming you're using axios for API calls

Vue.use(Vuex)

export default new Vuex.Store({
  state: {
    user: null,
    loading: false,
    error: null
  },
  mutations: {
    SET_USER (state, user) {
      state.user = user
    },
    SET_LOADING (state, loading) {
      state.loading = loading
    },
    SET_ERROR (state, error) {
      state.error = error
    }
  },
  actions: {
    async fetchUser ({ commit }, userId) {
      commit('SET_LOADING', true)
      commit('SET_ERROR', null) // Clear any previous errors
      try {
        const response = await axios.get(`https://api.example.com/users/${userId}`)
        commit('SET_USER', response.data)
      } catch (error) {
        commit('SET_ERROR', error.message)
      } finally {
        commit('SET_LOADING', false)
      }
    }
  },
  getters: {
    isLoading: state => state.loading,
    hasError: state => state.error,
    getUser: state => state.user
  }
})

在这个例子中：

• fetchUser 是一个异步操作，它接受 context（解构为 { commit }）和 userId 作为参数。
• commit 用于触发变异。
• SET_LOADING、SET_USER 和 SET_ERROR 是更新状态的mutations。
• axios.get 用于发起 API 调用。关键字 await 确保操作在继续之前等待 API 调用完成。
• 一个 try...catch...finally 块用于处理潜在的错误，并确保加载状态始终被重置。

Mutations的作用

Mutations负责 同步 更新状态。Actions 提交Mutations。这种关注点分离对于保持可预测的状态至关重要。你绝不应该在mutations中直接执行异步操作。

为什么Mutations必须是同步的：

Vue Devtools 跟踪应用于状态的所有变更。如果变更具有异步性，将无法准确追踪状态随时间的变化，导致调试变得极其困难。

示例： 上一个示例中的Mutations。

 mutations: {
    SET_USER (state, user) {
      state.user = user
    },
    SET_LOADING (state, loading) {
      state.loading = loading
    },
    SET_ERROR (state, error) {
      state.error = error
    }
  },

这些Mutations是简单且同步的。它们直接更新相应的状态属性。

异步操作和变异的最佳实践

1. 清晰的关注点分离

保持actions负责异步逻辑，而mutations负责同步状态更新。这使您的代码更易于维护和调试。

2. 使用 async/await 以提高清晰度

使用 async/await 比直接使用 .then() 和 .catch() 处理 Promise 更容易阅读和理解。

3. 优雅地处理错误

始终在您的操作中包含错误处理，以捕获来自 API 调用或其他异步操作的潜在错误。更新状态以反映错误，允许您的组件向用户显示适当的消息。

4. 管理加载状态

在你的 store 中使用加载状态来指示异步操作正在进行中。这允许你的组件在等待操作完成时显示加载指示器或禁用某些操作。

5. 行动中避免直接修改状态

永远不要在动作中直接修改状态。始终提交一个变异来更新状态。这确保了所有状态变化都能被 Vue Devtools 跟踪。

6. 考虑使用专用 API 服务

对于大型应用，可以考虑创建一个专门的 API 服务来处理所有 API 调用。这可以使你的操作保持清晰，专注于状态管理。

示例： 使用专门的 API 服务。

// api/userService.js
import axios from 'axios';

const API_BASE_URL = 'https://api.example.com';

export default {
  async getUser(userId) {
    try {
      const response = await axios.get(`${API_BASE_URL}/users/${userId}`);
      return response.data;
    } catch (error) {
      throw new Error(error.message);
    }
  }
};

// store.js
import Vue from 'vue'
import Vuex from 'vuex'
import userService from './api/userService'

Vue.use(Vuex)

export default new Vuex.Store({
  state: {
    user: null,
    loading: false,
    error: null
  },
  mutations: {
    SET_USER (state, user) {
      state.user = user
    },
    SET_LOADING (state, loading) {
      state.loading = loading
    },
    SET_ERROR (state, error) {
      state.error = error
    }
  },
  actions: {
    async fetchUser ({ commit }, userId) {
      commit('SET_LOADING', true)
      commit('SET_ERROR', null)
      try {
        const user = await userService.getUser(userId);
        commit('SET_USER', user)
      } catch (error) {
        commit('SET_ERROR', error.message)
      } finally {
        commit('SET_LOADING', false)
      }
    }
  },
  getters: {
    isLoading: state => state.loading,
    hasError: state => state.error,
    getUser: state => state.user
  }
})

这种方法使 fetchUser 操作更加清晰，更专注于状态管理，而 userService 则处理 API 调用逻辑。

实际案例与演示

示例 1：异步提交表单

考虑一个需要将数据发送到 API 并根据响应更新状态的表单提交场景。

// MyForm.vue
<template>
  <div>
    <form @submit.prevent="handleSubmit">
      <input type="text" v-model="formData.name" placeholder="Name">
      <input type="email" v-model="formData.email" placeholder="Email">
      <button type="submit" :disabled="isLoading">
        {{ isLoading ? 'Submitting...' : 'Submit' }}
      </button>
      <p v-if="error" style="color: red;">{{ error }}</p>
      <p v-if="successMessage" style="color: green;">{{ successMessage }}</p>
    </form>
  </div>
</template>

<script>
import { mapState, mapActions } from 'vuex';

export default {
  data() {
    return {
      formData: {
        name: '',
        email: ''
      }
    };
  },
  computed: {
    ...mapState(['isLoading', 'error', 'successMessage'])
  },
  methods: {
    ...mapActions(['submitForm']),
    async handleSubmit() {
      await this.submitForm(this.formData);
    }
  }
};
</script>

// store.js
import Vue from 'vue'
import Vuex from 'vuex'
import axios from 'axios'

Vue.use(Vuex)

export default new Vuex.Store({
  state: {
    isLoading: false,
    error: null,
    successMessage: null
  },
  mutations: {
    SET_LOADING (state, loading) {
      state.isLoading = loading
    },
    SET_ERROR (state, error) {
      state.error = error
    },
    SET_SUCCESS_MESSAGE (state, message) {
      state.successMessage = message
    }
  },
  actions: {
    async submitForm ({ commit }, formData) {
      commit('SET_LOADING', true)
      commit('SET_ERROR', null)
      commit('SET_SUCCESS_MESSAGE', null)
      try {
        const response = await axios.post('https://api.example.com/submit', formData)
        commit('SET_SUCCESS_MESSAGE', 'Form submitted successfully!')
      } catch (error) {
        commit('SET_ERROR', error.message)
      } finally {
        commit('SET_LOADING', false)
      }
    }
  },
  getters: {
    isLoading: state => state.isLoading,
    hasError: state => state.error,
    successMessage: state => state.successMessage
  }
})

在这个例子中：

• MyForm.vue 组件在表单提交时派发 submitForm 动作。
• submitForm 动作使用 axios.post 进行 API 调用。
• SET_LOADING、SET_ERROR 和 SET_SUCCESS_MESSAGE 变更根据 API 响应更新状态。
• 该组件在表单提交时显示加载指示器，并根据状态显示错误或成功消息。

示例2：异步操作的防抖处理

有时，你可能希望限制异步操作派发的速率。例如，当用户输入时搜索数据。防抖可以帮助防止过多的 API 调用。

// store.js
import Vue from 'vue'
import Vuex from 'vuex'
import axios from 'axios'
import debounce from 'lodash.debounce' // Install lodash: npm install lodash

Vue.use(Vuex)

export default new Vuex.Store({
  state: {
    searchResults: [],
    loading: false,
    error: null
  },
  mutations: {
    SET_SEARCH_RESULTS (state, results) {
      state.searchResults = results
    },
    SET_LOADING (state, loading) {
      state.loading = loading
    },
    SET_ERROR (state, error) {
      state.error = error
    }
  },
  actions: {
    async search ({ commit }, query) {
      commit('SET_LOADING', true)
      commit('SET_ERROR', null)
      try {
        const response = await axios.get(`https://api.example.com/search?q=${query}`)
        commit('SET_SEARCH_RESULTS', response.data)
      } catch (error) {
        commit('SET_ERROR', error.message)
      } finally {
        commit('SET_LOADING', false)
      }
    },
    debouncedSearch: debounce(function ({ dispatch }, query) {
      dispatch('search', query)
    }, 500) // Debounce for 500ms
  },
  getters: {
    searchResults: state => state.searchResults,
    isLoading: state => state.loading,
    hasError: state => state.error
  }
})

// SearchComponent.vue
<template>
  <div>
    <input type="text" v-model="searchQuery" @input="handleInput" placeholder="Search...">
    <div v-if="isLoading">Loading...</div>
    <div v-if="error" style="color: red;">{{ error }}</div>
    <ul>
      <li v-for="result in searchResults" :key="result.id">{{ result.name }}</li>
    </ul>
  </div>
</template>

<script>
import { mapState, mapActions } from 'vuex';

export default {
  data() {
    return {
      searchQuery: ''
    };
  },
  computed: {
    ...mapState(['searchResults', 'loading', 'error'])
  },
  methods: {
    ...mapActions(['debouncedSearch']),
    handleInput() {
      this.debouncedSearch(this.searchQuery);
    }
  }
};
</script>

在这个例子中：

• debouncedSearch 动作使用 lodash.debounce 来限制 search 动作派发的频率。
• SearchComponent.vue 组件在输入值变化时都会调用 debouncedSearch。
• 这可以防止 search 操作过于频繁地被派发，从而减少 API 调用的次数。