ReactError Fix2026 Updated
React Context Not Updating— Fixed [2026]
Also covers: useContext returns undefined · context value not changing · memo blocking updates
January 20266 min readReact 18 · Next.js
⚡ Complete Working Context Pattern
context/ThemeContext.jsx
import { createContext, useContext, useState, useMemo } from 'react'
const ThemeContext = createContext(null)
export function ThemeProvider({ children }) {
const [theme, setTheme] = useState('light')
const value = useMemo(() => ({ theme, setTheme }), [theme])
return <ThemeContext.Provider value={value}>{children}</ThemeContext.Provider>
}
export function useTheme() {
const ctx = useContext(ThemeContext)
if (!ctx) throw new Error('useTheme must be inside ThemeProvider')
return ctx
}Why Context Does Not Update Consumers
React context triggers re-renders in consumers only when the value prop on the Provider changes by reference. Same reference = no re-render. Most context problems are caused by wrong tree structure, mutating state directly, or unstable value references.
11 min
Wrap Consumers Inside the Provider
useContext returns undefined — component outside treeapp.jsx
// ❌ WRONG — UserProfile is outside the Provider
function App() {
return (
<div>
<UserProfile /> {/* cannot access context — undefined! */}
<UserProvider>
<Dashboard />
</UserProvider>
</div>
)
}
// ✅ CORRECT — Provider wraps all consumers
function App() {
return (
<UserProvider>
<UserProfile /> {/* ✅ has access */}
<Dashboard /> {/* ✅ has access */}
</UserProvider>
)
}22 min
Pass State (Not Plain Object) as Value
Context never updates — static valuecontext/CounterContext.jsx
import { createContext, useContext, useState } from 'react'
const CounterContext = createContext(null)
// ❌ WRONG — static object, never changes
export function CounterProvider({ children }) {
const count = 0
return <CounterContext.Provider value={{ count }}>{children}</CounterContext.Provider>
}
// ✅ CORRECT — useState triggers re-renders when count changes
export function CounterProvider({ children }) {
const [count, setCount] = useState(0)
return (
<CounterContext.Provider value={{ count, setCount }}>
{children}
</CounterContext.Provider>
)
}
// Consumers
function CounterDisplay() {
const { count } = useContext(CounterContext)
return <p>{count}</p> // re-renders when count changes
}
function IncrementButton() {
const { setCount } = useContext(CounterContext)
return <button onClick={() => setCount(c => c + 1)}>+1</button>
}32 min
Never Mutate the Context Value Directly
Mutation does not trigger re-rendercomponent.jsx
// ❌ WRONG — mutation does not change reference → no re-render
const { user } = useContext(UserContext)
user.name = 'John' // mutates the object — React does not see this
// ✅ CORRECT — replace via setter function from context
const { user, setUser } = useContext(UserContext)
setUser(prev => ({ ...prev, name: 'John' })) // new object → re-render
// ✅ In the Provider — always use setState for updates
export function UserProvider({ children }) {
const [user, setUser] = useState({ name: 'Guest', role: 'viewer' })
return <UserContext.Provider value={{ user, setUser }}>{children}</UserContext.Provider>
}42 min
Memoize Context Value With useMemo
Prevent unnecessary consumer re-rendersWithout memoization, a new value object is created on every parent render, causing all consumers to re-render even if the context data has not changed.
context/AuthContext.jsx
import { createContext, useState, useMemo } from 'react'
const AuthContext = createContext(null)
export function AuthProvider({ children }) {
const [user, setUser] = useState(null)
const [loading, setLoading] = useState(true)
// ❌ Without useMemo — new object every render → all consumers re-render
// return <AuthContext.Provider value={{ user, setUser, loading }}>
// ✅ With useMemo — only re-renders consumers when user or loading changes
const value = useMemo(
() => ({ user, setUser, loading }),
[user, loading]
)
return <AuthContext.Provider value={value}>{children}</AuthContext.Provider>
}51 min
One createContext() Per Context — No Duplicates
Two different context objects — import mismatchcontext/UserContext.js
// ❌ WRONG — createContext() in two files creates two DIFFERENT contexts
// fileA.js: export const UserCtx = createContext(null)
// fileB.js: export const UserCtx = createContext(null) ← different object!
// Provider uses fileA, consumer imports fileB → never connected
// ✅ CORRECT — one file, one createContext(), export everywhere
// context/UserContext.js
export const UserContext = createContext(null)
// Provider file imports from context/UserContext.js
// Consumer files import from context/UserContext.js
// All use the SAME context objectComplete Working Context Pattern
context/AppContext.jsx
import { createContext, useContext, useState, useCallback, useMemo } from 'react'
// 1. Create context
const AppContext = createContext(null)
// 2. Provider — owns the state
export function AppProvider({ children }) {
const [user, setUser] = useState(null)
const [theme, setTheme] = useState('light')
const login = useCallback((userData) => setUser(userData), [])
const logout = useCallback(() => setUser(null), [])
const toggleTheme = useCallback(() => setTheme(t => t === 'light' ? 'dark' : 'light'), [])
const value = useMemo(
() => ({ user, theme, login, logout, toggleTheme }),
[user, theme, login, logout, toggleTheme]
)
return <AppContext.Provider value={value}>{children}</AppContext.Provider>
}
// 3. Custom hook with guard
export function useApp() {
const ctx = useContext(AppContext)
if (!ctx) throw new Error('useApp must be used inside AppProvider')
return ctx
}
// 4. Usage
function NavBar() {
const { user, logout, toggleTheme } = useApp()
return (
<nav>
<span>{user?.name ?? 'Guest'}</span>
<button onClick={toggleTheme}>Toggle Theme</button>
{user && <button onClick={logout}>Logout</button>}
</nav>
)
}Prevention
- Provider must be an ancestor of all consumers in the component tree
- Always use useState or useReducer inside the Provider — never plain objects
- Use useMemo on context value to prevent unnecessary consumer re-renders
- Call createContext() once per context, export from one file
- Create a custom hook (useAuth, useTheme) that throws if used outside Provider
- Never mutate context values — always use the setter function
Frequently Asked Questions
Why is React context not updating consumers?+−
Context consumers only re-render when the context value reference changes. The three most common causes: 1) The consumer is not inside the Provider in the component tree, 2) You are mutating the context object instead of replacing it with setState, 3) A value object literal is created fresh every render but its contents did not change — use useMemo to stabilise.
useContext returns undefined — how to fix?+−
The component calling useContext is not wrapped inside the matching Provider. Move the Provider higher in the tree so it is an ancestor of all components that need the context. Also verify you are importing the same context object in both the Provider file and consumer files.
Context updates but component does not re-render?+−
React compares context value by reference. If you write <MyCtx.Provider value={{ count, setCount }}> directly, it creates a new object on every render but React may optimise away the update if contents appear the same. Use useMemo: const value = useMemo(() => ({ count, setCount }), [count]).
How do I update context from a child component?+−
Include the state setter in the context value: const [user, setUser] = useState(null); return <UserCtx.Provider value={{ user, setUser }}>{children}</UserCtx.Provider>. Children call setUser from useContext to update the shared state.
Should I use React Context or Zustand/Redux for state?+−
Context is best for low-frequency updates — theme, locale, auth session. For high-frequency updates (form inputs, real-time data), use Zustand, Jotai, or Redux Toolkit. Every context update re-renders all consumers, which can cause performance problems at high frequency.
Can I have multiple Providers?+−
Yes. You can nest multiple Providers for different concerns: <ThemeProvider><AuthProvider><LanguageProvider>{children}</LanguageProvider></AuthProvider></ThemeProvider>. Each context is independent. Components use only the context they need.
Need Expert Help?
We Build Production-Grade React Apps
Softplix builds full-stack React and Next.js applications. Need help with state management or context architecture? We can help.
Talk to an Engineer