Just Learn Code

Mastering Vuex Actions: Easy and Effective State Management for Vuejs Apps

Introduction to Vuex

As a Vue.js developer, you might have heard of Vuex, which is essentially a state management library. Vue.js, by itself, provides the ability to share data between components.

But when your application grows in complexity, managing the shared data between components becomes a difficult task. This is where Vuex comes into play it provides a centralized store that can be accessed by all components, making data management much simpler and organized.

Additionally, Vuex provides an architecture to handle actions, mutations, and state (data) in a manner that makes your code easy to reason about and maintain. In this article, we will explore the implementation of actions, compare it with the async function approach, and discuss the benefits of using actions in your Vue.js application.

Implementation of Actions in Vuex

Actions in Vuex allow you to handle asynchronous operations such as calling an API endpoint, getting data from a database, or performing long-running tasks. They help you keep your Vuex store clean, by delegating complex logic outside of the store and keeping it simple.

To create an action, you need to define it as a POJO (Plain Old JavaScript Object) with a `name` and `handler` property. The `handler` property is a function that receives a `context` object and an optional payload argument.

The `context` object exposes two important properties: `dispatch` and `commit`.

The `dispatch` function can be used to call other actions, whereas the `commit` function can be used to call mutations (more on mutations in another article).

Simply put, actions are the “gatekeepers” of the store.

Let’s take an example you want to call an API and store the data in your Vuex store.


const actions = {

async fetchUserData(context, payload) {

const data = await axios.get(‘https://myapi.com/user’, payload);

context.commit(‘updateUserData’, data);




The `fetchUserData` action is asynchronous, as it is making a network request using Axios. It is also receiving a `payload` argument from the component that calls it (payload here can be any data you want to send as input to the API), and the `context` object (which is a reference to the store) as the first argument.

The `commit` method is used to call mutations, but that is a topic for a later article.

Comparison with Async Function Approach

In a non-Vuex approach, you can use an async function to handle the same functionality calling an API and storing the data. The implementation would look something like this:


async function fetchUserData(payload) {

const data = await axios.get(‘https://myapi.com/user’, payload);

return data;


async function getUserData() {

const userData = await fetchUserData();

// do something with userData



Here, the `fetchUserData` function is fetching the data from the API, and the `getUserData` function is calling the `fetchUserData` function and doing something with the data.

The main difference between the two approaches is that the Vuex approach uses a `context` object to access the store, whereas the non-Vuex approach does not.

In the non-Vuex approach, you would need to pass the data or state between components, while in the Vuex approach, the store is a centralized data source that all components can access.

Moreover, using actions to handle API calls allows you to have a single place to handle error handling. In the `fetchUserData` example above, you could easily add a `try`/`catch` block to the action and handle the error there, instead of having to handle it in each component where it is called, cluttering the code.

Benefits of Using Actions in Vuex

Now that we understand the implementation of actions in Vuex, let’s explore the benefits of using them in your Vue.js application.

SubscribeAction API

One of the benefits of using actions is that they provide the `subscribeAction` API. This API allows you to listen to dispatched actions and execute a callback whenever an action has been triggered.


import { subscribeAction } from ‘vuex’;

export default {

created() {


before: ({ type, payload }) => {

console.log(`before action ${type}`, payload);


after: ({ type, payload }) => {

console.log(`after action ${type}`, payload);


error: ({ type, payload }) => {

console.error(`error in action ${type}`, payload);






Using the above code, you can listen to actions being called, log information or handle errors when they are called. You can also use plugins written for Vuex, that leverage this API to aid in debugging your Vuex code.

MapActions Function

The `mapActions` function provided by Vuex allows you to map your actions to Vue instance methods. This is particularly useful when you are using an action in multiple components, as you can avoid repetition and make your code more concise and readable.


import { mapActions } from ‘vuex’;

export default {

methods: {


async handleButtonClick() {

await this.fetchUserData({ id: 123 });

// do something after fetching user data





In this example, you are mapping the `fetchUserData` action to Vue instance methods, which means that you can call it using `this.fetchUserData` within the component’s methods. This simplifies the component code, making it more concise and readable.

Use in Vue Components

Lastly, actions are widely used in Vue components to perform asynchronous operations. Within a component’s `mounted` function, you can dispatch an action to fetch data, which is then rendered within the component’s template using computed properties.



Here, the component dispatches the `fetchUserData` action, which updates the Vuex store with the fetched user data, which is then rendered in the computed properties.


In conclusion, we have learned that Vuex is a state management library for Vue.js applications that provides a centralized store for data management. Actions in Vuex help keep the store clean by delegating complex logic outside of the store and handling asynchronous operations.

The benefits of using actions include the `subscribeAction` API, the `mapActions` function for concise and readable code, and their use in Vue components for fetching asynchronous data. By using actions in your Vue.js application, you can simplify your code and make it more organized and maintainable.

In summary, Vuex is a state management library for Vue.js applications that offers a centralized store for data management. Actions in Vuex allow for the handling of asynchronous operations, with benefits such as the subscribeAction API, mapActions function, and their use in Vue components.

By using actions, you can make your code more organized, concise, and maintainable. The key takeaway is that actions are an essential part of using Vuex, and learning to use them effectively can greatly improve your development process.

Overall, Vuex greatly simplifies data management in Vue.js apps, and it’s worth investing time to master it.

Popular Posts