What is useContext?
React Context is a way to manage state globally. It can be used together with the useState Hook to share state between deeply nested components more easily than with useState alone.
💡 The Problem: Prop drilling - passing props through many levels of components that don't need them, just to reach a deeply nested component.
The Prop Drilling Problem
Without Context, you might have to pass props through many levels:
function App() {
const [user, setUser] = useState("John");
return <Component1 user={user} />;
}
function Component1({ user }) {
return <Component2 user={user} />;
}
function Component2({ user }) {
return <Component3 user={user} />;
}
function Component3({ user }) {
return <h1>Hello {user}!</h1>;
}
⚠️ Problem: Component1 and Component2 don't use
user, they just pass it along!
The Solution: Context
Context allows you to share values between components without explicitly passing props:
Step 1: Create Context
import { createContext } from "react";
const UserContext = createContext();
Step 2: Provide Context
import { useState, createContext } from "react";
const UserContext = createContext();
function App() {
const [user, setUser] = useState("John");
return (
<UserContext.Provider value={user}>
<Component1 />
</UserContext.Provider>
);
}
Step 3: Use Context
import { useContext } from "react";
function Component1() {
return <Component2 />;
}
function Component2() {
return <Component3 />;
}
function Component3() {
const user = useContext(UserContext);
return <h1>Hello {user}!</h1>;
}
✨ No More Prop Drilling: Component1 and Component2 don't need to know about
user!
Complete Example
import { useState, createContext, useContext } from "react";
// 1. Create Context
const UserContext = createContext();
// 2. Provider Component
function App() {
const [user, setUser] = useState("Jesse Hall");
return (
<UserContext.Provider value={user}>
<h1>{`Hello ${user}!`}</h1>
<Component2 />
</UserContext.Provider>
);
}
function Component2() {
return (
<>
<h1>Component 2</h1>
<Component3 />
</>
);
}
function Component3() {
return (
<>
<h1>Component 3</h1>
<Component4 />
</>
);
}
function Component4() {
return (
<>
<h1>Component 4</h1>
<Component5 />
</>
);
}
// 3. Use Context
function Component5() {
const user = useContext(UserContext);
return (
<>
<h1>Component 5</h1>
<h2>{`Hello ${user} again!`}</h2>
</>
);
}
Context with Multiple Values
You can pass an object with multiple values:
const ThemeContext = createContext();
function App() {
const [theme, setTheme] = useState("light");
const [user, setUser] = useState("John");
const value = {
theme,
setTheme,
user,
setUser
};
return (
<ThemeContext.Provider value={value}>
<Page />
</ThemeContext.Provider>
);
}
function Page() {
const { theme, setTheme, user } = useContext(ThemeContext);
return (
<div className={theme}>
<h1>Welcome, {user}!</h1>
<button onClick={() => setTheme(theme === "light" ? "dark" : "light")}>
Toggle Theme
</button>
</div>
);
}
Custom Context Provider
Create a reusable provider component:
import { createContext, useState, useContext } from "react";
const AuthContext = createContext();
// Custom Provider
export function AuthProvider({ children }) {
const [user, setUser] = useState(null);
const login = (username) => {
setUser({ username });
};
const logout = () => {
setUser(null);
};
return (
<AuthContext.Provider value={{ user, login, logout }}>
{children}
</AuthContext.Provider>
);
}
// Custom Hook
export function useAuth() {
return useContext(AuthContext);
}
// Usage
function App() {
return (
<AuthProvider>
<Dashboard />
</AuthProvider>
);
}
function Dashboard() {
const { user, login, logout } = useAuth();
return (
<div>
{user ? (
<>
<h1>Welcome, {user.username}!</h1>
<button onClick={logout}>Logout</button>
</>
) : (
<button onClick={() => login("John")}>Login</button>
)}
</div>
);
}
Multiple Contexts
You can use multiple contexts in the same app:
function App() {
return (
<ThemeProvider>
<AuthProvider>
<LanguageProvider>
<Dashboard />
</LanguageProvider>
</AuthProvider>
</ThemeProvider>
);
}
When to Use Context
✅ Good Use Cases:
- Theme (light/dark mode)
- User authentication
- Language/localization
- Shopping cart
- Global settings
⚠️ When NOT to Use:
- Frequently changing values (causes many re-renders)
- Simple prop drilling (1-2 levels deep)
- Local component state
Best Practices
- Create separate contexts for different concerns
- Use custom providers and hooks for cleaner code
- Place providers as low as possible in the tree
- Memoize context values to avoid unnecessary re-renders
- Consider using a state management library for complex state
Context vs Props
| Feature | Props | Context |
|---|---|---|
| Passing Data | Explicit, parent to child | Implicit, through tree |
| Best For | Component-specific data | Global/shared data |
| Reusability | More reusable | Less reusable |
What's Next?
Now that you understand useContext, you're ready to learn about useRef for accessing DOM elements and persisting values!