Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchWindows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallRedux is a pattern and JavaScript library for managing shared application state. It makes changes follow a visible path: the UI dispatches an action, reducer logic calculates the next state, and the UI updates from that state. For modern React applications, the recommended approach is Redux Toolkit (RTK) with React-Redux—not hand-written legacy Redux patterns.
What is Redux?
Redux centralizes application state that needs to be shared and updated across different parts of an app. It is a standalone JavaScript library, so it can be used with different UI frameworks; React is its most common pairing in the official documentation. The Redux Essentials tutorial describes it as “a pattern and library for managing and updating global application state.” Read the Redux Essentials overview.
As an Amazon Associate I earn from qualifying purchases.
The central idea is not simply “put everything in one place.” Redux establishes a consistent way to describe changes and calculate their results. That makes it easier to inspect when, where, and why shared state changes.
Actions, reducers, and the store
- State is the data representing the application at a particular moment.
- An action describes what happened, such as a user adding a post to their favorites. It is a description of an event, not the logic that calculates the result.
- A reducer receives the current state and an action, then calculates the next state.
- The store holds the shared state and coordinates updates and notifications to subscribers.
The distinction between an action and a reducer is important: the action says what happened; the reducer determines how that event changes state.
#1 Best Overall
The Redux data flow
- The UI renders using the current state.
- A user interaction or other event causes the UI to dispatch an action.
- The store runs the relevant reducer logic with the current state and action.
- The reducer calculates the next state, and the store updates its state.
- The store notifies subscribers, allowing the UI to render using the new state.
Why should I use Redux?
Redux is useful when application state is shared broadly, changes often, or has update rules that are difficult to coordinate. Its predictable flow gives a team a common structure for handling those changes. Separating update logic from UI components can also make behavior easier to inspect and test.
That structure has a cost: Redux introduces concepts, indirection, constraints, and code that a small app may not need. The decision is a tradeoff between immediate simplicity and a more consistent structure as shared state and update complexity grow. The official guidance is explicit that not every app needs Redux. See the Redux principles and guidance.
When Redux is a good fit
- Many screens or components need to read or update the same data.
- State changes frequently, and it is useful to track what caused each change.
- Update logic or asynchronous workflows are becoming hard to follow in components.
- A medium-to-large codebase has multiple developers who benefit from predictable conventions.
When local state is simpler
Keep state in a component when it is only relevant there. Whether a single dropdown is open, for example, usually does not need to become shared application state. Moving every temporary UI detail into Redux adds coordination overhead without providing a corresponding benefit.
The Tool Desk
Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Rank #2
In practice, decide state by state: if multiple parts of the app need to coordinate around it, Redux may be justified; if only one component uses it, local component state is usually the simpler choice.
How modern Redux architecture works
Redux’s maintainers recommend Redux Toolkit as the standard way to write Redux logic. In a React app, React-Redux is the official binding that lets components access the store. RTK supplies the standard store setup and tools such as slices. Learn why Redux Toolkit is the recommended approach.
A typical React + Redux Toolkit app has these parts:
- Store: Created with RTK’s
configureStore, which combines feature reducers and sets up common defaults. - Feature slices: Related state, reducer logic, and generated action creators are grouped together with
createSlice. - Components: Read needed data with React-Redux’s
useSelectorand dispatch actions withuseDispatch. TypeScript projects often define pre-typed app hooks. - App root: Wraps the React component tree in
<Provider store={store}>so descendants can access the store. - Async work: Uses thunks for logic that needs access to
dispatchandgetState; RTK Query is the Redux Toolkit option for server-data fetching and caching.
With an object of reducers, configureStore combines them into a root reducer. It also adds thunk middleware, enables Redux DevTools Extension integration, and includes development-only immutability and serializability checks. The official app-structure tutorial walks through these pieces.
Free tools Windows power users keep installed
One-click scans. No signup required.
What a slice does
A slice is a feature-oriented collection of reducer logic and its related actions. RTK’s createSlice generates action creators from the reducer definitions. It uses Immer, so reducer code can use mutation-like syntax while still producing immutable state updates.
That syntax does not make reducers a place for side effects. A reducer should calculate state from its inputs—current state and action—and should not perform asynchronous work. Put async logic in a thunk or use RTK Query for fetching and caching server data.
Rank #4
A blogging app’s state shape
For a blogging app, the store might combine users, posts, and comments slice reducers. Each reducer manages its own feature branch, and the keys in the object passed to configureStore determine the names of those branches.
const store = configureStore({
reducer: {
users: usersReducer,
posts: postsReducer,
comments: commentsReducer,
},
})In this example, a post component can select post data from the posts branch, while a comments component can read the comments branch. Slices keep feature update rules organized without requiring the entire app’s state logic to live in one file.
A small example: a counter slice
A counter is useful for seeing the basic wiring, but it is intentionally simpler than the shared, asynchronous state patterns that motivate Redux in larger apps.
Best Value
import { createSlice, configureStore } from '@reduxjs/toolkit'
const counterSlice = createSlice({
name: 'counter',
initialState: { value: 0 },
reducers: {
incremented(state) {
state.value += 1
},
decremented(state) {
state.value -= 1
},
},
})
const store = configureStore({
reducer: { counter: counterSlice.reducer },
})
store.dispatch(counterSlice.actions.incremented())createSlice generates the action creators, while the slice reducer calculates the updated counter state. The mutation-like line is supported by RTK’s Immer integration; it does not mean the existing Redux state is being changed directly.
In React, the component tree needs a Provider connected to this store. Components can then read the counter through useSelector and dispatch the generated action through useDispatch. The official tutorials show this wiring in a fuller application rather than treating a counter as a complete app architecture.
How to learn Redux in the right order
If you are building a React app, start with the official Redux Essentials tutorial. It teaches current Redux Toolkit patterns, React-Redux hooks, and RTK Query through a social media feed application with more representative features than a counter. The official learning sequence recommends Essentials first for app builders. Browse the Redux tutorials.
Redux Fundamentals is a useful next step if you want to understand lower-level mechanics and why the recommended abstractions exist. Essentials assumes familiarity with JavaScript and React; the tutorial also lists basic TypeScript and asynchronous JavaScript knowledge among its prerequisites.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
