Redux
Last updated
Was this helpful?
LAMBDA_LABS_Family_Promise
Last updated
Was this helpful?
Back To Top\
\
Redux is a state container for JavaScript apps.
Official website:
Use devarchy to add a library to the catalog
Contents
Aims to improve the overall structure of the source code. Makes reasoning about the code easier.
Side Effects / Asynchronous Actions
Aims to make parts of the source code easier to read/write.
Boilerplates / Scaffolds / Starter Kits / Generators / Stack Ensembles
Redux's concepts
Why immutable data structures
Side Effects
Reading the aforementioned material will get you a good start for writing apps with Redux. If you are curious for more, check out following resources.
Functional Programming - Basics
Reactive Programming
Functional Programming - Going beyond
Monads
Introduction > Getting Started: First steps with React Redux
React Redux 7.1+ requires React 16.8.3 or later, in order to make use of React Hooks.
To use React Redux with your React app, install it as a dependency:
If you are using TypeScript, the React Redux types are maintained separately in DefinitelyTyped, but included as a dependency of the react-redux package, so they should be installed automatically. If you still need to install them manually, run:
React Redux includes a <Provider /> component, which makes the Redux store available to the rest of your app:
React Redux provides a pair of custom React hooks that allow your React components to interact with the Redux store.
useSelector reads a value from the store state and subscribes to updates, while useDispatch returns the store's dispatch method to let you dispatch actions.
Redux maintainer Mark Erikson appeared on the "Learn with Jason" show to explain how we recommend using Redux today. The show includes a live-coded example app that shows how to use Redux Toolkit and React-Redux hooks with Typescript, as well as the new RTK Query data fetching APIs.
Welcome to the Redux Essentials tutorial! This tutorial will introduce you to Redux and teach you how to use it the right way, using our latest recommended tools and best practices. By the time you finish, you should be able to start building your own Redux applications using the tools and patterns you've learned here.
This page will focus on showing you how to use Redux the right way, and explain just enough of the concepts so that you can understand how to build Redux apps correctly.
We've tried to keep these explanations beginner-friendly, but we do need to make some assumptions about what you know already:
If you're not already comfortable with those topics, we encourage you to take some time to become comfortable with them first, and then come back to learn about Redux. We'll be here when you're ready!
You should make sure that you have the React and Redux DevTools extensions installed in your browser:
React DevTools Extension:
Redux DevTools Extension:
It helps to understand what this "Redux" thing is in the first place. What does it do? What problems does it help me solve? Why would I want to use it?
Redux is a pattern and library for managing and updating application state, using events called "actions". It serves as a centralized store for state that needs to be used across your entire application, with rules ensuring that the state can only be updated in a predictable fashion.
Redux helps you manage "global" state - state that is needed across many parts of your application.
The patterns and tools provided by Redux make it easier to understand when, where, why, and how the state in your application is being updated, and how your application logic will behave when those changes occur. Redux guides you towards writing code that is predictable and testable, which helps give you confidence that your application will work as expected.
Redux helps you deal with shared state management, but like any tool, it has tradeoffs. There are more concepts to learn, and more code to write. It also adds some indirection to your code, and asks you to follow certain restrictions. It's a trade-off between short term and long term productivity.
Redux is more useful when:
You have large amounts of application state that are needed in many places in the app
The app state is updated frequently over time
The logic to update that state may be complex
The app has a medium or large-sized codebase, and might be worked on by many people
Not all apps need Redux. Take some time to think about the kind of app you're building, and decide what tools would be best to help solve the problems you're working on.
Redux is a small standalone JS library. However, it is commonly used with several other packages:
React-Redux#
Redux Toolkit#
Redux DevTools Extension#
Before we dive into some actual code, let's talk about some of the terms and concepts you'll need to know to use Redux.
Let's start by looking at a small React counter component. It tracks a number in component state, and increments the number when a button is clicked:
It is a self-contained app with the following parts:
The state, the source of truth that drives our app;
The view, a declarative description of the UI based on the current state
The actions, the events that occur in the app based on user input, and trigger updates in the state
This is a small example of "one-way data flow":
State describes the condition of the app at a specific point in time
The UI is rendered based on that state
When something happens (such as a user clicking a button), the state is updated based on what occurred
The UI re-renders based on the new state
One way to solve this is to extract the shared state from the components, and put it into a centralized location outside the component tree. With this, our component tree becomes a big "view", and any component can access the state or trigger actions, no matter where they are in the tree!
By defining and separating the concepts involved in state management and enforcing rules that maintain independence between views and states, we give our code more structure and maintainability.
This is the basic idea behind Redux: a single centralized place to contain the global state in your application, and specific patterns to follow when updating that state to make the code predictable.
"Mutable" means "changeable". If something is "immutable", it can never be changed.
JavaScript objects and arrays are all mutable by default. If I create an object, I can change the contents of its fields. If I create an array, I can change the contents as well:
This is called mutating the object or array. It's the same object or array reference in memory, but now the contents inside the object have changed.
In order to update values immutably, your code must make _copies_** of existing objects/arrays, and then modify the copies**.
We can do this by hand using JavaScript's array / object spread operators, as well as array methods that return new copies of the array instead of mutating the original array:
Redux expects that all state updates are done immutably. We'll look at where and how this is important a bit later, as well as some easier ways to write immutable update logic.
There are some important Redux terms that you'll need to be familiar with before we continue:
Actions#
An action is a plain JavaScript object that has a type field. You can think of an action as an event that describes something that happened in the application.
The type field should be a string that gives this action a descriptive name, like "todos/todoAdded". We usually write that type string like "domain/eventName" , where the first part is the feature or category that this action belongs to, and the second part is the specific thing that happened.
An action object can have other fields with additional information about what happened. By convention, we put that information in a field called payload.
A typical action object might look like this:
Action Creators#
An action creator is a function that creates and returns an action object. We typically use these so we don't have to write the action object by hand every time:
Reducers#
A reducer is a function that receives the current state and an action object, decides how to update the state if necessary, and returns the new state: (state, action) => newState. You can think of a reducer as an event listener which handles events based on the received action (event) type.
info
Reducers must always follow some specific rules:
They should only calculate the new state value based on the state and action arguments
They are not allowed to modify the existing state. Instead, they must make immutable updates, by copying the existing state and making changes to the copied values.
They must not do any asynchronous logic, calculate random values, or cause other "side effects"
We'll talk more about the rules of reducers later, including why they're important and how to follow them correctly.
The logic inside reducer functions typically follows the same series of steps:
Check to see if the reducer cares about this action
If so, make a copy of the state, update the copy with new values, and return it
Otherwise, return the existing state unchanged
Here's a small example of a reducer, showing the steps that each reducer should follow:
Reducers can use any kind of logic inside to decide what the new state should be: if/else, switch, loops, and so on.
Detailed Explanation: Why Are They Called 'Reducers?'
Array.reduce() takes a callback function as an argument, which will be called one time for each item in the array. It takes two arguments:
previousResult, the value that your callback returned last time
currentItem, the current item in the array
The first time that the callback runs, there isn't a previousResult available, so we need to also pass in an initial value that will be used as the first previousResult.
If we wanted to add together an array of numbers to find out what the total is, we could write a reduce callback that looks like this:
Notice that this addNumbers "reduce callback" function doesn't need to keep track of anything itself. It takes the previousResult and currentItem arguments, does something with them, and returns a new result value.
A Redux reducer function is exactly the same idea as this "reduce callback" function! It takes a "previous result" (the state), and the "current item" (the action object), decides a new state value based on those arguments, and returns that new state.
If we were to create an array of Redux actions, call reduce(), and pass in a reducer function, we'd get a final result the same way:
We can say that Redux reducers reduce a set of actions (over time) into a single state. The difference is that with Array.reduce() it happens all at once, and with Redux, it happens over the lifetime of your running app.
Store#
The current Redux application state lives in an object called the store .
The store is created by passing in a reducer, and has a method called getState that returns the current state value:
Dispatch#
The Redux store has a method called dispatch. The only way to update the state is to call store.dispatch() and pass in an action object. The store will run its reducer function and save the new state value inside, and we can call getState() to retrieve the updated value:
You can think of dispatching actions as "triggering an event" in the application. Something happened, and we want the store to know about it. Reducers act like event listeners, and when they hear an action they are interested in, they update the state in response.
We typically call action creators to dispatch the right action:
Selectors#
Selectors are functions that know how to extract specific pieces of information from a store state value. As an application grows bigger, this can help avoid repeating logic as different parts of the app need to read the same data:
Earlier, we talked about "one-way data flow", which describes this sequence of steps to update the app:
State describes the condition of the app at a specific point in time
The UI is rendered based on that state
When something happens (such as a user clicking a button), the state is updated based on what occurred
The UI re-renders based on the new state
For Redux specifically, we can break these steps into more detail:
Initial setup:
A Redux store is created using a root reducer function
The store calls the root reducer once, and saves the return value as its initial state
When the UI is first rendered, UI components access the current state of the Redux store, and use that data to decide what to render. They also subscribe to any future store updates so they can know if the state has changed.
Updates:
Something happens in the app, such as a user clicking a button
The app code dispatches an action to the Redux store, like dispatch({type: 'counter/increment'})
The store runs the reducer function again with the previous state and the current action, and saves the return value as the new state
The store notifies all parts of the UI that are subscribed that the store has been updated
Each UI component that needs data from the store checks to see if the parts of the state they need have changed.
Each component that sees its data has changed forces a re-render with the new data, so it can update what's shown on the screen
Here's what that data flow looks like visually:
Redux does have a number of new terms and concepts to remember. As a reminder, here's what we just covered:
Summary
Redux is a library for managing global application state
Redux is typically used with the React-Redux library for integrating Redux and React together
Redux Toolkit is the recommended way to write Redux logic
Redux uses a "one-way data flow" app structure
State describes the condition of the app at a point in time, and UI renders based on that state
When something happens in the app:
The UI dispatches an action
The store runs the reducers, and the state is updated based on what occurred
The store notifies the UI that the state has changed
The UI re-renders based on the new state
Redux uses several types of code
Actions are plain objects with a type field, and describe "what happened" in the app
Reducers are functions that calculate a new state value based on previous state + an action
A Redux store runs the root reducer whenever an action is dispatched
Lately one of the biggest debates in the frontend world has been about Redux. Not long after its release, Redux became one of the hottest topics of discussion. Many favored it while others pointed out issues.
Redux allows you to manage your app’s state in a single place and keep changes in your app more predictable and traceable. It makes it easier to reason about changes occurring in your app. But all of these benefits come with tradeoffs and constraints. One might feel it adds up boilerplate code, making simple things a little overwhelming; but that depends upon the architecture decisions.
One simple answer to this question is you will realize for yourself when you need Redux. If you’re still confused as to whether you need it, you don’t. This usually happens when your app grows to the scale where managing app state becomes a hassle; and you start looking out for making it easy and simple.
State management is essentially a way to facilitate communication and sharing of data across components. It creates a tangible data structure to represent the state of your app that you can read from and write to. That way, you can see otherwise invisible states while you’re working with them.
Most libraries, such as React, Angular, etc. are built with a way for components to internally manage their state without any need for an external library or tool. It does well for applications with few components, but as the application grows bigger, managing states shared across components becomes a chore.
In an app where data is shared among components, it might be confusing to actually know where a state should live. Ideally, the data in a component should live in just one component, so sharing data among sibling components becomes difficult.
For instance, in React, to share data among siblings, a state has to live in the parent component. A method for updating this state is provided by the parent component and passed as props to these sibling components.
Here’s a simple example of a login component in React. The input of the login component affects what is displayed by its sibling component, the status component:
>
Now imagine what happens when a state has to be shared between components that are far apart in the component tree. The state has to be passed from one component to another until it gets to where it is needed.
Basically, the state will have to be lifted up to the nearest parent component and to the next until it gets to an ancestor that is common to both components that need the state, and then it is passed down. This makes the state difficult to maintain and less predictable. It also means passing data to components that do not need it.
It’s clear that state management gets messy as the app gets complex. This is why you need a state management tool like Redux that makes it easier to maintain these states. Let’s get a good overview of Redux concepts before considering its benefits.
The way Redux works is simple. There is a central store that holds the entire state of the application. Each component can access the stored state without having to send down props from one component to another.
There are three building parts: actions, store, and reducers. Let’s briefly discuss what each of them does. This is important because they help you understand the benefits of Redux and how it’s to be used. We’ll be implementing a similar example to the login component above but this time in Redux.
Simply put, actions are events. They are the only way you can send data from your application to your Redux store. The data can be from user interactions, API calls, or even form submissions.
Actions are sent using the store.dispatch() method. Actions are plain JavaScript objects, and they must have a type property to indicate the type of action to be carried out. They must also have a payload that contains the information that should be worked on by the action. Actions are created via an action creator.
Here’s an example of an action that can be carried out during login in an app:
{ type: "LOGIN", payload: { username: "foo", password: "bar" } }
Here is an example of its action creator:
const setLoginStatus = (name, password) => { return { type: "LOGIN", payload: { username: "foo", password: "bar" } } }
As explained earlier, the action must contain the type property and then the other payload to be stored.
Reducers are pure functions that take the current state of an application, perform an action, and return a new state. These states are stored as objects, and they specify how the state of an application changes in response to an action sent to the store.
It is based on the reduce function in JavaScript, where a single value is calculated from multiple values after a callback function has been carried out.
Here is an example of how reducers work in Redux:
const LoginComponent = (state = initialState, action) => { switch (action.type) { case "LOGIN": return state.map(user => { if (user.username !== action.username) { return user; } if (user.password == action.password) { return { ...user, login_status: "LOGGED IN" } } }); default: return state; } };
As pure functions, they do not change the data in the object passed to them or perform any side effect in the application. Given the same object, they should always produce the same result.
The store holds the application state. It is highly recommended to keep only one store in any Redux application. You can access the state stored, update the state, and register or unregister listeners via helper methods.
Let’s create a store for our login app:
const store = createStore(LoginComponent);
Actions performed on the state always return a new state. Thus, the state is very easy and predictable.
Now that we know a little more about Redux, let’s go back to our login component example that was implemented earlier and see how Redux can improve the component.
With Redux, there’s one general state in the store, and each component has access to the state. This eliminates the need to continuously pass state from one component to another. You can also select the slice from the store for a particular component; this makes your app more optimized.
Redux allows developers to intercept all actions dispatched from components before they are passed to the reducer function. This interception is done via middlewares.
Technically, middlewares are functions that call the next method received in an argument after processing the current action. These are called after every dispatch.
Here’s what a simple middleware looks like:
function simpleMiddleware({ getState, dispatch }) { return function(next){ return function(action){ const nextAction = next(action); const state = getState(); return nextAction; } } }
This might look a little overwhelming, but in most cases, you might not need to create your own middleware since the huge Redux community has already made a number of them available. If you feel middleware is required, you will enjoy it because it gives you a lot of power to do tons of great work with the best abstraction.
When using Redux with React, states will no longer need to be lifted up. This makes it easier for you to trace which action causes any change.
As you can see in the example above, the component does not need to provide any state or method for its children components to share data among themselves. Everything is handled by Redux. This greatly simplifies the app and makes it easier to maintain.
This is the primary reason why you should use Redux, but it’s not the only benefit. Take a look at the list below for a summary of what you stand to gain by using Redux for state management.
In Redux, the state is always predictable. If the same state and action are passed to a reducer, the same result is always produced because reducers are pure functions. The state is also immutable and is never changed. This makes it possible to implement arduous tasks like infinite undo and redo. It is also possible to implement time travel — that is, the ability to move back and forth among the previous states and view the results in real time.
Redux makes it easy to debug an application. By logging actions and state, it is easy to understand coding errors, network errors, and other forms of bugs that might come up during production.
You might assume that keeping the app’s state global would result in some performance degradation. To a large extent, that’s not the case.
React Redux implements many performance optimizations internally so that your own connected component only rerenders when it actually needs to.
It is easy to test Redux apps since functions used to change the state of pure functions.
You can persist some of the app’s state to local storage and restore it after a refresh. This can be really nifty.
Redux can also be used for server-side rendering. With it, you can handle the initial render of the app by sending the state of an app to the server along with its response to the server request. The required components are then rendered in HTML and sent to the clients.
The LogRocket Redux middleware package adds an extra layer of visibility into your user sessions. LogRocket logs all actions and state from your Redux stores.
- Automatic actions, reducers and validation for Redux.
- Immutable and type-checked state and actions for Redux.
- The Cerebral signals running with Redux.
- The Elm Architecture in JavaScript.
- Small, simple and immutable ORM to manage relational data in your Redux store.
- Redux middleware for calling an API.
- Higher-order reducer to ignore Redux actions.
- Collection of generic functions for writing Redux reducers to operate on various data structures.
- Reducer library for Redux.
- Redux bindings for client-side search.
- Logger middleware for Redux.
- Redux-immutable is used to create an equivalent function of Redux combineReducers that works with Immutable.js state.
- Selector library for Redux.
- Manages in-flight requests with a Redux reducer to avoid issuing duplicate requests.
- Higher order reducer to add undo/redo functionality to Redux state containers.
- Bug reporter and bug playback tool for Redux.
- Transducer utilities for Redux.
- Persistence layer for Redux with flexible backends.
- Persist and rehydrate a Redux store.
- Alternative side effect model for Redux apps.
- Redux middleware for resolving and rejecting promises with conditional optimistic updates.
- You write pure functions, redux-effects handles the rest.
- Thunk middleware for Redux.
- Provides decorator for resolving async props in react-router, extremely useful for handling server-side rendering in React.
- Port of elm-effects and the Elm Architecture to Redux that allows you to sequence your effects naturally and purely by returning them from your reducers.
- Redux toolset for keeping all the side effects inside your reducers while maintaining their purity.
- Redux middleware for organizing business logic and action side effects.
- RxJS middleware for action side effects in Redux using "Epics".
- Composable, testable and typable side effects.
- Opinionated lib to create actions and reducers for Redux.
- Set of standard actions and reducers for Redux CRUD Applications.
- Another Redux DevTools Monitor.
- Diff logger between states for Redux.
- Chart monitor for Redux DevTools.
- DevTools for Redux with hot reloading, action replay, and customizable UI.
- Dispatch your actions manually to test if your app Reacts well.
- Resizable and movable dock for Redux DevTools monitors.
- Filterable tree view monitor for Redux DevTools.
- The default monitor for Redux DevTools with a tree view.
- Redux DevTools remotely.
- Redux middleware to automatically generate tests for reducers through ui interaction.
- Official React bindings for Redux.
- Universal Routing & Rendering with React & Redux was too hard. Now it's easy.
- Set of wrapper components to facilitate using Material UI with Redux Form.
- It allows you to request async data, store them in Redux state and connect them to your React component.
- Router made for Redux and made for universal apps. Stop using the router as a controller, it's just state.
- Redux bindings for React Router – keep your router state inside your Redux store.
- Ruthlessly simple bindings to keep react-router and Redux in sync.
- Scalable reducer management & powerful data fetching for React Router & Redux.
- Higher Order Component using react-redux to keep form state in a Redux store.
- Create forms easily in React with Redux.
- Local component state via Redux.
- Easy UI state management for React Redux.
- Flux Standard Action utilities for Redux.
- FSA-compliant promise middleware for Redux.
- Easy way to keep your backbone collections and Redux store in sync.
- Connect your Redux front-end to your falcor back-end.
- RxJS middleware for action side effects in Redux using "Epics".
- Reimplementation of Redux using RxJS.
- RxJS utilities for Redux.
- Redux'ish Functional State Management using RxJS.
- Redux store enhancer that allows automatic synchronization between electron processes.
- Bindings for Redux in deku < v2.
- Redux middleware that wraps exceptions in actions and sends them to Rollbar with current state.
- React Redux toolset for the WordPress API.
- Opinionated CLI for building Redux/React apps quicker.
- React/Redux stack (not a boilerplate kit).
- Boilerplate for Chrome Extension React.js project.
- Npm package that lets you jump right into coding React and Redux with universal (isomorphic) rendering. Only manage Express setups or Webpack configurations if you want to.
- Starting point for building isomorphic React applications with Core 1, leveraging existing techniques.
- CLI tools for Redux: next-gen functional Flux/React with devtools.
- React Webpack Generator including Redux support.
- Small (8kb), batteries-included Redux store to reduce boilerplate and promote good habits.
- Minimal Redux.
does a great job at explaining Redux's core principles.
The of React's official documentation explains well what immutable data structures are and why they play an important role.
gives a good insight on Side Effects in the context of Redux.
This goes over basic concepts of functional programming while building a YouTube instant search demo app.
This explains Reactive Programming with clarity.
Well written that talks about interesting computer science concepts implemented in functional languages and how these apply to JavaScript.
Curious about monads? Wikipedia gives a good and explains monads in more details with graphics and simple examples.
is the official UI bindings layer for . It lets your React components read data from a Redux store, and dispatch actions to the store to update state.
The recommended way to start new apps with React and Redux is by using the or for , which takes advantage of and React Redux's integration with React components.
You'll also need to and in your app.
See for a transcript and links to the example app source.
The of the is our official resource for all questions related to learning and using Redux. Reactiflux is a great place to hang out, ask questions, and learn - come join us!
You can also ask questions on using the .
In Part 1 of this tutorial, we'll cover the key concepts and terms you need to know to use Redux, and in we'll examine a basic React + Redux app to see how the pieces fit together.
Starting in , we'll use that knowledge to build a small social media feed app with some real-world features, see how those pieces actually work in practice, and talk about some important patterns and guidelines for using Redux.
Redux can integrate with any UI framework, and is most frequently used with React. is our official package that lets your React components interact with a Redux store by reading pieces of state and dispatching actions to update the store.
is our recommended approach for writing Redux logic. It contains packages and functions that we think are essential for building a Redux app. Redux Toolkit builds in our suggested best practices, simplifies most Redux tasks, prevents common mistakes, and makes it easier to write Redux applications.
The shows a history of the changes to the state in your Redux store over time. This allows you to debug your applications effectively, including using powerful techniques like "time-travel debugging".
However, the simplicity can break down when we have multiple components that need to share and use the same state, especially if those components are located in different parts of the application. Sometimes this can be solved by to parent components, but that doesn't always help.
"Reducer" functions get their name because they're similar to the kind of callback function you pass to the method.
The method lets you take an array of values, process each item in the array one at a time, and return a single final result. You can think of it as "reducing the array down to one value".
We've seen each of the individual pieces of a Redux app. Next, continue on to , where we'll look at a full working example to see how the pieces fit together.
Remember, this data is not needed by the parent component, but because its children need to share data, it has to provide a state.
Reducers take the previous state of the app and return a new state based on the action passed to it.
class App extends React.Component { render() { return (<Status user={}/> <Login login={this.props.setLoginStatus}/> </div> ) } }
Building on the example Login component discussed in the last section, we might want to sanitize the user’s input before it reaches our store for further processing. This can be achieved via .
Redux is strict about how code should be organized, which makes it easier for someone with knowledge of Redux to understand the structure of any Redux application. This generally makes it easier to maintain. This also helps you segregate your business logic from your component tree. For large scale apps, it’s critical to
Besides logging, it has , persist actions on page refresh, etc. For medium- and large-scale apps, debugging takes more time then actually developing features. Redux DevTools makes it easy to taker advantage of all Redux has to offer.
We have discussed the major features of Redux and why Redux is beneficial to your app. While Redux has its benefits, that does not mean you should go about adding Redux in all of your apps. Your application .
One major benefit of Redux is to add direction to decouple “what happened” from “how things change.” However, you should only implement Redux if you determine your project needs a state management tool. Drag to Bookmarks to add to Bookmarks! ≡Data Structures Practice SiteConnectFollowConnect
