Back to Course

Learn React

0% Complete
0/0 Steps
Lesson 23 of 32
In Progress

Introduction to Redux

Redux is a popular library for managing state in JavaScript applications, especially in combination with the React library. In this article, we will cover the basics of Redux and how it can be used to manage state in your React application.

What is Redux?

Redux is a library that helps manage state in your application. It was designed to be used with the React library, but it can be used with any other JavaScript framework as well.

The main idea behind Redux is that you have a single store for your entire application’s state. This store is then modified using pure functions called reducers.

Redux also introduces the concept of actions, which are objects that describe the changes that you want to make to your store. When you dispatch an action, it is passed to the reducer, which then updates the store accordingly.

Why Use Redux?

One of the main benefits of using Redux is that it helps keep your state management organized and predictable. By having a single source of truth for your application’s state and using pure functions to modify it, you can easily track the changes that are made to your state and understand how they are affecting your application.

Another benefit of Redux is that it allows you to easily scale your application as it grows. By having a centralized store, it becomes easier to share state between different parts of your application and to add new features without having to worry about managing state in multiple places.

Setting Up Redux in Your React Application

To use Redux in your React application, you will need to install the redux and react-redux libraries. You can do this using npm or yarn:

npm install redux react-redux

Once you have these libraries installed, you can create your store and configure your reducers.

Creating the Store

To create your store, you will need to use the createStore function from the redux library. This function takes in your reducer function as an argument and returns a store object that you can use to dispatch actions and get the current state of your application.

Here is an example of how to create a store for a simple counter application:

import { createStore } from 'redux';

function counterReducer(state = 0, action) {
  switch (action.type) {
    case 'INCREMENT':
      return state + 1;
    case 'DECREMENT':
      return state - 1;
      return state;

const store = createStore(counterReducer);

Connecting Your Store to Your React Components

Redux is a powerful tool for managing application state, but it can be a bit intimidating to get started with. One key concept to understand when using Redux is how to connect your store to your React components.

To connect your store to your React components, you’ll need to use the react-redux library. This library provides a set of higher-order components that you can use to connect your store to your components.

Here’s an example of how you might use the react-redux connect higher-order component to connect a simple component to your store:

import { connect } from 'react-redux';

class MyComponent extends React.Component {
  render() {
    const { data } = this.props;
    return (

const mapStateToProps = (state) => {
  return {

export default connect(mapStateToProps)(MyComponent);

In this example, the connect higher-order component takes in a mapStateToProps function as an argument. This function is used to map the state in your store to the props of your component. In this case, we’re mapping the data property of our store to the data prop of our component.

Once your component is connected to your store, it will automatically re-render whenever the state in your store changes. This makes it easy to keep your components up-to-date with the latest data from your store.


In conclusion, Redux is a powerful tool for managing state in a React application. It allows you to centralize your state and make it easier to update and maintain. By connecting your store to your React components, you can easily access and update your application’s state from anywhere in your code. While there is a bit of a learning curve to using Redux, it is a valuable tool to have in your toolkit for larger and more complex React applications.


To review these concepts, we will go through a series of exercises designed to test your understanding and apply what you have learned.

Create a Redux store and initialize it with a state object. The state object should have a property called “count” with a value of 0.

import { createStore } from 'redux';

const initialState = {
  count: 0

const store = createStore(reducer, initialState);

Create a reducer function that increments the count property of the state object by 1.

const reducer = (state, action) => {
  switch (action.type) {
    case 'INCREMENT':
      return {
        count: state.count + 1
      return state;

Create an action creator function that returns an action object with a type of ‘INCREMENT’.

const increment = () => {
  return {
    type: 'INCREMENT'

Dispatch the ‘INCREMENT’ action to the store.


Subscribe to the store and log the current state to the console every time the state updates.

store.subscribe(() => {