Creating Context
First, create a Context object to serve as a container for sharing data.
// MyContext.js
import React from 'react';
const MyContext = React.createContext({
user: null,
setUser: () => {},
});
export default MyContext;Here, a default value is defined with user and setUser properties. user stores the current logged-in user’s information, and setUser is a function to update the user value.
Using Provider
Use the Provider component at the root of the component tree where state needs to be shared. The Provider passes state to all child components without explicitly passing props.
// App.js
import React from 'react';
import MyContext from './MyContext';
import Login from './Login';
import Profile from './Profile';
function App() {
const [user, setUser] = React.useState(null);
return (
<MyContext.Provider value={{ user, setUser }}>
<div className="App">
<Login />
<Profile />
</div>
</MyContext.Provider>
);
}
export default App;In this example, the App component is the root for the Provider, passing user and setUser to MyContext. The Login and Profile components can now access this context.
Using Consumer
The Consumer component subscribes to Context changes, re-rendering when the Provider’s value changes.
// Profile.js
import React from 'react';
import MyContext from './MyContext';
function Profile() {
return (
<MyContext.Consumer>
{({ user }) => (
<div>
<h1>Welcome, {user ? user.name : 'Guest'}!</h1>
</div>
)}
</MyContext.Consumer>
);
}
export default Profile;However, using Consumer can make component code verbose, especially in nested components. The useContext Hook is a more concise alternative.
Using useContext Hook
The useContext Hook provides a cleaner way to consume Context.
// Profile.js
import React, { useContext } from 'react';
import MyContext from './MyContext';
function Profile() {
const { user } = useContext(MyContext);
return (
<div>
<h1>Welcome, {user ? user.name : 'Guest'}!</h1>
</div>
);
}
export default Profile;Updating Context Values
In App.js, the setUser function updates the user value. Add a login button in the Login component to update user when clicked.
// Login.js
import React, { useContext } from 'react';
import MyContext from './MyContext';
function Login() {
const { setUser } = useContext(MyContext);
const handleLogin = () => {
setUser({ name: 'John Doe', email: 'john.doe@example.com' });
};
return (
<div>
<button onClick={handleLogin}>Login</button>
</div>
);
}
export default Login;Advanced Usage of Context API
Conditional Rendering with Context
For a theme-switching feature, use Context to manage the current theme and render conditionally based on it.
// ThemeContext.js
import React from 'react';
const ThemeContext = React.createContext('light');
export default ThemeContext;
// App.js
import React from 'react';
import ThemeContext from './ThemeContext';
import ToggleTheme from './ToggleTheme';
import Content from './Content';
function App() {
const [theme, setTheme] = React.useState('light');
return (
<ThemeContext.Provider value={theme}>
<div className={`App ${theme}`}>
<ToggleTheme setTheme={setTheme} />
<Content />
</div>
</ThemeContext.Provider>
);
}
export default App;// Content.js
import React, { useContext } from 'react';
import ThemeContext from './ThemeContext';
function Content() {
const theme = useContext(ThemeContext);
return (
<div className={`content ${theme}`}>
{/* Your content here */}
</div>
);
}
export default Content;Context with Higher-Order Components
Combine Context with higher-order components (HOCs) to provide additional logic or data to components.
// withTheme.js
import React from 'react';
import ThemeContext from './ThemeContext';
const withTheme = Component => props => {
const theme = React.useContext(ThemeContext);
return <Component {...props} theme={theme} />;
};
export default withTheme;
// EnhancedComponent.js
import React from 'react';
import withTheme from './withTheme';
const EnhancedComponent = ({ theme }) => (
<div className={`enhanced-component ${theme}`}>
{/* Your component logic here */}
</div>
);
export default withTheme(EnhancedComponent);Combining Context with Hooks
Using useReducer
For complex state management, combine useReducer with Context to provide robust state transition logic.
// UserContext.js
import React from 'react';
const UserContext = React.createContext();
const userReducer = (state, action) => {
switch (action.type) {
case 'LOGIN':
return { ...state, isLoggedIn: true, user: action.payload };
case 'LOGOUT':
return { ...state, isLoggedIn: false, user: null };
default:
return state;
}
};
export { UserContext, userReducer };
// App.js
import React, { useReducer } from 'react';
import { UserContext, userReducer } from './UserContext';
import Login from './Login';
import Dashboard from './Dashboard';
function App() {
const [state, dispatch] = useReducer(userReducer, {
isLoggedIn: false,
user: null,
});
return (
<UserContext.Provider value={{ state, dispatch }}>
<div className="App">
<Login />
<Dashboard />
</div>
</UserContext.Provider>
);
}
export default App;Using useCallback and useMemo
To prevent unnecessary re-renders, use useCallback and useMemo to optimize values passed to Context.
// App.js
import React, { useState, useCallback, useMemo } from 'react';
import MyContext from './MyContext';
import ComponentA from './ComponentA';
import ComponentB from './ComponentB';
function App() {
const [value, setValue] = useState(0);
const increment = useCallback(() => {
setValue(prevValue => prevValue + 1);
}, []);
const memoizedValue = useMemo(() => ({ value }), [value]);
return (
<MyContext.Provider value={{ value: memoizedValue, increment }}>
<ComponentA />
<ComponentB />
</MyContext.Provider>
);
}
export default App;Performance Optimization
Using React.memo
For components using Context, apply React.memo to prevent unnecessary re-renders.
// Profile.js
import React, { useContext } from 'react';
import MyContext from './MyContext';
const Profile = () => {
const { user } = useContext(MyContext);
return (
<div>
<h1>Welcome, {user ? user.name : 'Guest'}!</h1>
</div>
);
};
export default React.memo(Profile);Using useMemo and useCallback
In the Provider, use useMemo and useCallback to ensure Context values don’t create new references on every render, reducing re-renders in consuming components.



