使用 React Context API 管理用户状态

在 React 应用中管理用户状态是一项很常见的需求。本文将通过一个简单的例子来介绍如何使用 React 的 Context API 创建一个用户上下文，方便在组件之间共享登录信息和相关操作。

示例一：

代码示例：User Context Provider

以下是一个使用 Context API 的代码示例：

import { useState, createContext } from "react";

// 创建一个上下文对象，用于共享用户数据和登录/登出功能
export const UserContext = createContext();

// 创建 UserContextProvider 组件，作为用户上下文的提供者
export const UserContextProvider = ({ children }) => {
  // 定义用户状态，初始值为 null，表示未登录
  const [user, setUser] = useState(null);

  // login 方法用于设置用户状态，模拟用户登录
  const login = () => {
    setUser({ name: "pedro", email: "pedro@pedrotech.co" });
  };

  // logout 方法用于清空用户状态，模拟用户登出
  const logout = () => {
    setUser(null);
  };

  // contextValue 对象包含了需要共享的用户状态及登录/登出方法
  const contextValue = {
    user, // 当前用户信息
    login, // 登录方法
    logout, // 登出方法
  };

  // 返回一个包含用户上下文提供者的组件，向子组件传递上下文值
  return (
    <UserContext.Provider value={contextValue}>{children}</UserContext.Provider>
  );
};

代码示例：User Profile

以下是使用 UserContext 的示例组件 UserProfile：

import React, { useContext } from "react";
import { UserContext } from "./user-context-provider"; // 注意导入路径是否正确

const UserProfile = () => {
  // 使用 useContext 来获取上下文中的 user、login 和 logout 方法
  const { user, login, logout } = useContext(UserContext);

  return (
    <div>
      {/* 判断用户是否登录，如果没有登录显示登录按钮，否则显示用户信息和登出按钮 */}
      {user ? (
        <>
          <h2>Welcome, {user.name}</h2>
          <p>Email: {user.email}</p>
          <button onClick={logout}>Logout</button>
        </>
      ) : (
        <>
          <h2>Please log in</h2>
          <button onClick={login}>Login</button>
        </>
      )}
    </div>
  );
};

export default UserProfile;

关键点解析

1. `createContext()` - 创建上下文

首先，我们使用 createContext() 来创建一个上下文对象 UserContext，它将用来在整个应用中共享用户数据和操作。这一步很关键，因为它为用户信息的全局共享提供了基础。

export const UserContext = createContext();

通过创建 UserContext，我们能够在应用的任意组件中访问到用户数据，而不需要一层层地将 props 传递下去。

2. `UserContextProvider` 组件 - 提供上下文

UserContextProvider 是一个自定义组件，它使用了 UserContext.Provider 来为子组件提供用户状态和操作。

export const UserContextProvider = ({ children }) => {
  // 用户状态定义
  const [user, setUser] = useState(null);

  // 登录方法
  const login = () => {
    setUser({ name: "pedro", email: "pedro@pedrotech.co" });
  };

  // 登出方法
  const logout = () => {
    setUser(null);
  };

  // 共享的上下文值
  const contextValue = {
    user,
    login,
    logout,
  };

  // 向子组件提供上下文值
  return (
    <UserContext.Provider value={contextValue}>{children}</UserContext.Provider>
  );
};

用户状态：使用 useState(null) 初始化用户状态。user 为 null 时表示当前没有用户登录。
登录/登出方法：login 和 logout 方法分别用于更新用户状态。这些方法会被传递给消费者组件，以便这些组件可以执行登录和登出操作。
contextValue 对象：contextValue 包含了 user 状态和登录、登出的方法。这个对象通过 UserContext.Provider 传递给所有子组件。

3. `UserContext.Provider` - 传递上下文值

UserContextProvider 使用 UserContext.Provider 包裹其子组件，并通过 value 属性将上下文数据传递下去，这样子组件就可以访问到这些共享的值。

<UserContext.Provider value={contextValue}>{children}</UserContext.Provider>

这意味着只要组件在 UserContextProvider 的子树中，它们就能访问到 user 状态，以及调用 login 和 logout 方法。

使用上下文的步骤

为了使用 UserContext，你可以利用 React 的 useContext Hook，像这样：

import { useContext } from "react";
import { UserContext } from "./user-context-provider";

const UserProfile = () => {
  const { user, login, logout } = useContext(UserContext);

  return (
    <div>
      {user ? (
        <>
          <h1>Welcome, {user.name}!</h1>
          <button onClick={logout}>Logout</button>
        </>
      ) : (
        <>
          <h1>Please log in</h1>
          <button onClick={login}>Login</button>
        </>
      )}
    </div>
  );
};

在上面的代码中，我们使用 useContext(UserContext) 来获取上下文值，并根据用户的状态来渲染不同的内容。

如果 user 存在，显示欢迎消息和登出按钮。
如果 user 为 null，则显示登录按钮。

示例二：

import React, { createContext, useContext } from "react";

// 创建一个 Context，用于共享标题的层级信息，默认值为 1（表示从 h1 开始）
const LevelContext = createContext(1);

// Section 组件，用于包裹一段内容，并提升标题层级
export function Section({ children }) {
  // 使用 useContext 钩子获取当前的层级值
  const level = useContext(LevelContext);
  // 计算下一个层级，层级每次加 1，但最多为 h6
  const nextLevel = Math.min(level + 1, 6);

  return (
    // 使用 LevelContext.Provider 提供新的层级值
    <LevelContext.Provider value={nextLevel}>
      <section className="section">
        {/* 渲染子组件 */}
        {children}
      </section>
    </LevelContext.Provider>
  );
}

// Heading 组件，根据当前层级渲染对应的标题标签（h1~h6）
export function Heading({ children }) {
  // 从 LevelContext 中获取当前的层级值
  const level = useContext(LevelContext);

  // 根据当前层级动态渲染对应的标题标签
  switch (level) {
    case 1:
      return <h1>{children}</h1>;
    case 2:
      return <h2>{children}</h2>;
    case 3:
      return <h3>{children}</h3>;
    case 4:
      return <h4>{children}</h4>;
    case 5:
      return <h5>{children}</h5>;
    case 6:
    default:
      return <h6>{children}</h6>;
  }
}

// 示例 App 组件，展示 Section 和 Heading 的嵌套使用
export default function App() {
  return (
    // 最外层 Section，初始层级为 1（默认值来自 LevelContext 的 createContext）
    <Section>
      {/* Heading 组件，层级为 h1 */}
      <Heading>标题 1</Heading>

      {/* 嵌套的 Section，层级递增为 2 */}
      <Section>
        {/* Heading 组件，层级为 h2 */}
        <Heading>标题 2</Heading>

        {/* 再次嵌套的 Section，层级递增为 3 */}
        <Section>
          {/* Heading 组件，层级为 h3 */}
          <Heading>标题 3</Heading>
        </Section>
      </Section>
    </Section>
  );
}