Lesson 10-React Context API and Provider

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.

Share your love