Skip to main content
TOPIC 1 OF 6 · 2 MIN READ

State Management in React: Context API vs. Redux

Understanding the differences between Context API and Redux is crucial for choosing the right state management solution for your React application. Context API is React's built-in solution, while Redux is a powerful external library for complex state management.

Key concepts

Context API

React's built-in feature that allows components to share state across the component tree without prop drilling. Provides a simple way to manage global state for applications with relatively simple state requirements.

Redux

A predictable state container for JavaScript applications. Uses a unidirectional data flow and enforces state management through actions, reducers, and a global store.

Step by step

When to Use Context API:

  • When you need to share global state like themes, authentication, or user preferences.
  • For small to medium-sized applications where state complexity is low.

Context API Limitations:

  • Performance issues may arise if the context value changes frequently.
  • Harder to debug and test compared to Redux.

When to Use Redux:

  • The application has complex or large-scale global state.
  • You need strict control and predictability over state transitions.
  • Debugging and performance optimization are critical.
  • You need advanced middleware capabilities for handling side effects.

Examples

Context API - Create Context:

const MyContext = React.createContext();

Context API - Provide Context:

function App() {
  const sharedState = { user: 'Alice' };

  return (
    <MyContext.Provider value={sharedState}>
      <ChildComponent />
    </MyContext.Provider>
  );
}

Context API - Consume Context:

function ChildComponent() {
  const context = React.useContext(MyContext);
  return <p>{`User: ${context.user}`}</p>;
}

Redux - Define Actions:

const increment = { type: 'INCREMENT' };
const decrement = { type: 'DECREMENT' };

Redux - Define Reducer:

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

Redux - Create Store:

import { legacy_createStore } from 'redux';
const store = legacy_createStore(counterReducer);

Redux - Dispatch Actions:

store.dispatch(increment); // Updates state to { count: 1 }
store.dispatch(decrement); // Updates state to { count: 0 }

Stuck on this one? Talk to Sumit.

Keys: F focus mode · ← → previous / next topic · Esc leave focus