⚛️ React useContext Hook

Chapter 13 of 15

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

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!