Maison > Article > interface Web > Qu'est-ce que Vuex ? Guide du débutant sur Vuex 4
Cet article vous présente Vuex et explique comment utiliser Vuex dans les applications. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère qu'il sera utile à tout le monde.
Vuex
est un outil essentiel dans l'écosystème Vue.js. Mais les développeurs qui découvrent Vuex peuvent être rebutés par des termes tels que « modèle de gestion d'état » et confus quant à la raison pour laquelle ils ont réellement besoin de Vuex. [Recommandations associées : "Tutoriel vue.js"]
Cet article est une introduction à Vuex. Bien sûr, il couvrira également les concepts avancés de Vuex et vous montrera comment utiliser Vuex. dans les candidatures.
Pour comprendre Vuex, vous devez d'abord comprendre les problèmes qu'il résout.
Supposons que nous développions une application de chat multi-utilisateurs. L'interface dispose d'une liste d'utilisateurs, d'une fenêtre de discussion privée, d'une boîte de réception avec historique des discussions et d'une barre de notification qui informe l'utilisateur des messages non lus d'autres utilisateurs qui ne sont pas actuellement consultés.
Des millions d'utilisateurs discutent chaque jour avec des millions d'autres utilisateurs via notre application. Cependant, certaines personnes se sont plaintes d'un problème ennuyeux : le volet de notification donne parfois de fausses notifications. Les utilisateurs sont avertis d'un nouveau message non lu, mais lorsqu'ils le consultent, il s'agit simplement d'un message déjà consulté.
Ce que décrit cet auteur est une situation réelle que les développeurs de Facebook ont rencontrée dans leur système de chat il y a quelques années. Pour résoudre ce problème, les développeurs créent une architecture d'application appelée "Flux". Flux constitue la base de Vuex, Redux et d'autres bibliothèques similaires.
Les développeurs de Facebook sont aux prises avec le problème des « notifications zombies » depuis un certain temps. Ils ont finalement réalisé que sa persistance était plus qu'un simple défaut : elle indiquait un défaut sous-jacent dans l'architecture de l'application.
Cette faille est la plus facile à comprendre de manière abstraite : lorsqu'il existe plusieurs composants dans une application qui partagent des données, la complexité de leurs interconnexions augmente au point que l'état des données ne peut pas être prédit ou compris. Par conséquent, l’application ne peut pas être étendue ou maintenue.
Flux
est un modèle, pas une bibliothèque. Nous ne pouvons pas aller sur Github pour télécharger Flux. Il s'agit d'un modèle de conception similaire à MVC. Des bibliothèques comme Vuex et Redux implémentent le modèle Flux de la même manière que d'autres frameworks implémentent le modèle MVC.
En fait, Vuex n'implémente pas tout Flux, seulement un sous-ensemble. Mais ne vous inquiétez pas pour le moment, concentrons-nous sur la compréhension des principes clés qu'il suit.
Les composants peuvent disposer de données locales dont ils ont uniquement besoin de connaître. Par exemple, la position de la barre de défilement dans un composant liste d'utilisateurs peut être indépendante des autres composants.
Cependant, toutes les données qui doivent être partagées entre les composants (c'est-à-dire les données d'application) doivent être conservées dans un emplacement distinct, distinct des composants qui les utilisent.
Cet emplacement unique est appelé un « magasin ». Le composant doit lire les données de l'application à partir de cet emplacement et ne peut pas conserver sa propre copie pour éviter les conflits ou les divergences.
import { createStore } from "vuex"; // Instantiate our Vuex store const store = createStore({ // "State" 组件的应用程序数据 state () { return { myValue: 0 }; } }); // 组件从其计算的属性访问 state const MyComponent = { template: "<div>{{ myValue }}</div>", computed: { myValue () { return store.state.myValue; } } };
les composants peuvent lire librement les données de store
. Mais les données de store
ne peuvent pas être modifiées, du moins pas directement.
Au lieu de cela, ils doivent informer store
de leur intention de modifier les données, et store
est responsable d'effectuer les modifications via un ensemble défini de fonctions (appelées mutation
).
Pourquoi cette approche ? Si l'on centralise la logique de changement des données, alors si le statut est incohérent, il suffit de le vérifier au même endroit, sans aller dans chaque fichier spécifique. Nous minimisons la possibilité qu'un composant aléatoire (peut-être dans un module tiers) modifie les données de manière inattendue.
const store = createStore({ state() { return { myValue: 0 }; }, mutations: { increment (state, value) { state.myValue += value; } } }); // 需要更新值吗? // 错误的,不要直接更改 store 值 store.myValue += 10; // 正确的,调用正确的 mutations。 store.commit('increment', 10);
Le débogage des incohérences des données est beaucoup plus facile si l'application implémente les deux principes ci-dessus dans son architecture. Il est possible de journaliser les commits et d'observer comment l'état change (cela est en effet possible en utilisant Vue Devtools).
Mais si notre mutation
est appelé de manière asynchrone, cette capacité sera affaiblie. Nous connaissons l'ordre des soumissions, mais nous ne connaissons pas l'ordre dans lequel les composants les soumettent. La
Synchronisationmutation
garantit que l'état ne dépend pas de la séquence et du timing imprévisibles des événements.
Avec toutes ces connaissances de base, nous pouvons enfin résoudre le problème - Vuex est une bibliothèque qui nous aide à implémenter l'architecture Flux dans les applications Vue. En appliquant les principes ci-dessus, Vuex maintient les données de nos applications dans un état transparent et prévisible, même lorsque les données sont partagées entre plusieurs composants.
Maintenant que nous avons une compréhension de haut niveau de Vuex, voyons comment créer une application basée sur Vuex dans un projet réel.
Pour démontrer l'utilisation de Vuex, nous avons mis en place une application de tâches simple. Vous pouvez accéder à des exemples fonctionnels du code ici.
示例地址:https://codesandbox.io/s/happ...
如果大家自己的电脑尝试一波,那么可以使用下面的命令:
vue create vuex-example
cd vuex-example npm i -S vuex@4 npm run serve
现在,创建 Vuex store,在项目中创建 src/store/index.js
:
mkdir src/store touch src/store/index.js
打开文件并导入createStore
方法。此方法用于定义store
及其特性。现在,我们导出该store
,以便在Vue应用中能访问它。
// src/store/index.js import { createStore } from "vuex"; export default createStore({});
为了可以从任何组件中访问 Vuex store,我们需要在主文件中导入 store
模块,并将store
作为插件安装在主Vue实例上
// src/main.js import { createApp } from "vue"; import App from "@/App"; import store from "@/store"; const app = createApp(App); app.use(store); app.mount("#app");
如上所述,Vuex 的重点是通常在大型应用程序中创建可扩展的全局状态。 但是,我们可以在一个简单的待办应用程序中演示其功能。
完成后效果如下所示:
现在,删除 HelloWorld 文件:
rm src/components/HelloWorld.vue
现在,添加一个新组件 TodoNew
,它负责创建新的待办事项。
touch src/components/TodoNew.vue
打开 TodoNew.vue
并输入以下内容:
// src/components/TodoNew.vue <template> <form @submit.prevent="addTodo"> <input type="text" placeholder="Enter a new task" v-model="task" /> </form> </template>
现在转到组件定义,有两个局部状态属性-task
和给新待办事项提供唯一标识符的id
。
// src/components/TodoNew.vue <template>...</template> <script> export default { data() { return { task: "", id: 0 }; }, methods: { addTodo: function() { // } } }; </script>
过会,我们会创建一个显示待办事项的组件。 由于它和TodoNew
组件都需要访问相同的数据,因此这是我们在 Vuex 存储中保存的全局state
的理想选择。
现在,回到state
并定义属性状态。 这里使用 Vux4 提供的 createStore
函数,该函数返回一个对象。 该对象具有一个属性 todos
,它是一个空数组。
// src/store/index.js import { createStore } from "vuex"; export default createStore({ state () { return { todos: [] } } });
从原则2可以知道,Vuex state 不能直接更改,需要定义mutator
函数。
现在,我们向store
添加一个mutation
属性,并添加一个函数属性addTodo
。 所有mutator
方法第一个参数。 第二个可选参数是 store,第二个是传递的数据。
// src/store/index.js import { createStore } from "vuex"; export default createStore({ state () { return { todos: [] } }, mutations: { addTodo (state, item) { state.todos.unshift(item); } } });
mutation
现在,可以在TodoNew
组件中使用它,在 TodoNew
组件定义一个addTodo
方法。
要访问store
,我们可以使用全局属性this.$store
。 使用commit
方法创建一个新的mutation
。 需要传递了两个参数-首先是mutation
的名称,其次是我们要传递的对象,是一个新的待办事项(由id
和task
值组成)。
// src/components/TodoNew.vue methods: { addTodo: function() { const { id, task } = this; this.$store.commit("addTodo", { id, task }); this.id++; this.task = ""; } }
到目前为止:
用户将待办事项通过输入框输入,并绑定到 task
变量。
提交表单后,将调用addTodo
方法
创建一个待办事项对象并将其“提交”到store
中。
// src/components/TodoNew.vue <template> <form @submit.prevent="addTodo"> <input type="text" placeholder="Enter a new task" v-model="task" /> </form> </template> <script> export default { data() { return { task: "", id: 0 }; }, methods: { addTodo: function() { const { id, task } = this; this.$store.commit("addTodo", { id, task }); this.id++; this.task = ""; } } }; </script>
现在,我们已经创建了用于添加待办事项的功能。 接下来,就是把它们显示出来。
创建一个新组件TodoList.vue
文件。
touch src/components/TodoList.vue
内容如下:
// src/components/TodoList.vue <template> <ul> <li v-for="todo in todos" :key="todo.id" > {{ todo.description }} </li> </ul> </template>
todos
是一个计算属性,我们在其中返回Vuex store 的内容。
// src/components/TodoList.vue <script> export default { computed: { todos() { // } } }; </script>
与直接访问store
内容不同,getter
是类似于存储的计算属性的函数。在将数据返回到应用程序之前,这些工具非常适合过滤或转换数据。
例如,下面有getTodos
,它返回未过滤的状态。 在许多情况下,可以使用filter
或map
来转换此内容。
todoCount
返回todo
数组的长度。
通过确保组件愿意保留数据的本地副本,getter
有助于实现原则1,即单一数据来源。
// src/store/index.js export default createStore({ ... getters: { getTodos (state) { return state.todos; }, todoCount (state) { return state.todos.length; } } })
返回TodoList
组件,我们通过返回this.$store.getters.getTodos
来完成功能。
// src/components/TodoList.vue <script> export default { computed: { todos() { return this.$store.getters.getTodos; } } }; </script>
App.vue
要完成此应用程序,现在要做的就是导入并在App.vue
中声明我们的组件。
// src/App.vue <template> <p> <h1>To-Do List</h1> <p> <TodoNew /> <TodoList /> </p> </p> </template> <script> import TodoNew from "@/components/TodoNew.vue"; import TodoList from "@/components/TodoList.vue"; export default { components: { TodoNew, TodoList } }; </script>
显然,在大型应用程序中,拥有全局状态管理解决方案将有助于让我们的应用程序可预测和可维护。
Mais pour des projets relativement petits, j'ai parfois l'impression qu'utiliser Vuex est excessif, et il est plus raisonnable que chacun suive les besoins réels.
Avantages de Vuex :
Inconvénients de Vuex :
Anglais Adresse originale : https://vuejsdevelopers.com/2017/05/15/vue-js-what-is-vuex/
Auteur : Anthony Gore
Adresse de réimpression : https :/ /segmentfault.com/a/1190000039872016
Pour plus de connaissances liées à la programmation, veuillez visiter : Introduction à la programmation ! !
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!