How does React handle context state management?

React covers this with 2 copy-ready snippets on this page. The "Context + Reducer Pattern" snippet in React uses `const StateCtx = createContext(null);`.

Which code does the React example use?

The "Context + Reducer Pattern" snippet uses `const StateCtx = createContext(null);`, from the Patterns section of the React cheat sheet.

What other React snippets are shown for "context state management"?

Besides "Context + Reducer Pattern", this page also shows "Context for Global State".

Context state management

2 snippets in React

Also written as state management context

REReact

Context + Reducer Pattern

RE · Patterns

Syntax

const StateCtx = createContext(null);
const DispatchCtx = createContext(null);

function Provider({ children }) {
  const [state, dispatch] = useReducer(reducer, init);
  return (
    <StateCtx.Provider value={state}>
      <DispatchCtx.Provider value={dispatch}>
        {children}
      </DispatchCtx.Provider>
    </StateCtx.Provider>
  );
}

Example

const TodoStateContext = createContext(null);
const TodoDispatchContext = createContext(null);

function todoReducer(state, action) {
  switch (action.type) {
    case 'ADD':
      return [...state, { id: crypto.randomUUID(), text: action.text, done: false }];
    case 'TOGGLE':
      return state.map(t =>
        t.id === action.id ? { ...t, done: !t.done } : t
      );
    case 'DELETE':
      return state.filter(t => t.id !== action.id);
    default:
      throw new Error(`Unhandled: ${action.type}`);
  }
}

function TodoProvider({ children }) {
  const [todos, dispatch] = useReducer(todoReducer, []);
  return (
    <TodoStateContext.Provider value={todos}>
      <TodoDispatchContext.Provider value={dispatch}>
        {children}
      </TodoDispatchContext.Provider>
    </TodoStateContext.Provider>
  );
}

function useTodos() {
  return useContext(TodoStateContext);
}
function useTodoDispatch() {
  return useContext(TodoDispatchContext);
}

Note This pattern provides Redux-like state management with built-in React APIs. Splitting state and dispatch into separate contexts prevents components that only dispatch actions from re-rendering when state changes.

Context for Global State

RE · State Management

Syntax

// Create -> Provide -> Consume
const Ctx = createContext(defaultValue);
<Ctx.Provider value={value}>...
const value = useContext(Ctx);

Example

// Locale context for internationalization
const LocaleContext = createContext('en');

function LocaleProvider({ children }) {
  const [locale, setLocale] = useState('en');

  const translations = useMemo(
    () => loadTranslations(locale),
    [locale]
  );

  const value = useMemo(
    () => ({ locale, setLocale, t: (key) => translations[key] || key }),
    [locale, translations]
  );

  return (
    <LocaleContext.Provider value={value}>
      {children}
    </LocaleContext.Provider>
  );
}

function useLocale() {
  return useContext(LocaleContext);
}

// Usage in any component
function WelcomeBanner() {
  const { t, locale } = useLocale();
  return <h1>{t('welcome_message')} ({locale})</h1>;
}

Note Context is ideal for low-frequency updates like theme, locale, and auth. For high-frequency updates (e.g., mouse position), context can cause excessive re-renders -- consider useSyncExternalStore or a dedicated state library.

Frequently asked questions

How does React handle context state management?: React covers this with 2 copy-ready snippets on this page. The "Context + Reducer Pattern" snippet in React uses `const StateCtx = createContext(null);`.
Which code does the React example use?: The "Context + Reducer Pattern" snippet uses `const StateCtx = createContext(null);`, from the Patterns section of the React cheat sheet.
What other React snippets are shown for "context state management"?: Besides "Context + Reducer Pattern", this page also shows "Context for Global State".
Is there anything to watch out for?: Yes. For "Context + Reducer Pattern": This pattern provides Redux-like state management with built-in React APIs. Splitting state and dispatch into separate contexts prevents components that only dispatch actions from re-rendering when state changes.