Skip to content

5. 异步与共享状态

5.1. 示例 19:异步处理

许多事情都发生在“以后”:定时器的滴答、按键、服务器的响应。[Angular] 为此依赖 [RxJS] 库及其可观察对象(Observable)。[React] 没有自己专门的异步工具:我们把状态、副作用及其清理组合起来,封装在 Hook 中;并且从 [React] 19 开始,[use()] 和 [<Suspense>] 让我们可以等待一个 promise。

5.1.1. 倒计时

// =========================================================================
// 19-asynchronous/src/hooks/useCountdown.ts - Hook 中的定时器
// -------------------------------------------------------------------------
// 从起始值倒数到 0,每秒一个值。当计数
// 到达 0……或者组件消失时(清理),定时器会被停止。
// =========================================================================

import { useEffect, useState } from 'react';

export function useCountdown(start: number): number {
  const [remaining, setRemaining] = useState(start);

  // [remaining > 0]:当这个条件变化时,副作用会被重新启动 - 因此
  // 只有一次,即计数到达 0 时(此时定时器被停止)
  const active = remaining > 0;
  useEffect(() => {
    if (!active) return;
    const timer = setInterval(() => setRemaining((r) => r - 1), 1000);
    return () => clearInterval(timer);
  }, [active]);

  return remaining;
}
  • 第 11 行:计数器;
  • 第 15 行:计数器;
  • 第 16–20 行:副作用只依赖 [active]:它在启动时执行(定时器启动),之后只会在计数到 0 时再执行一次;这时它的清理会停止定时器,而新的执行什么也不做。[setRemaining((r) => r - 1)] 使用更新的“函数”形式:定时器只创建一次,看不到 [remaining] 的新值;而函数则会接收到当前值。

5.1.2. 防抖

// =========================================================================
// 19-asynchronous/src/hooks/useDebouncedValue.ts - “防抖”
// -------------------------------------------------------------------------
// 返回收到的值……但只有当它在 delay 毫秒内
// 没有再变化时才返回。对于边输入边搜索:我们
// 等待用户停顿之后再查询服务器,
// 而不是每按一个键就发送一个请求。
// 原理:每个新值都会重新启动副作用,副作用的清理函数
// 会取消上一个值的定时器。
// =========================================================================

import { useEffect, useState } from 'react';

export function useDebouncedValue<T>(value: T, delay: number): T {
  const [debounced, setDebounced] = useState(value);

  useEffect(() => {
    const timer = setTimeout(() => setDebounced(value), delay);
    return () => clearTimeout(timer); // 在结束之前又有按键:取消
  }, [value, delay]);

  return debounced;
}

对于“边输入边搜索”功能,我们等待用户停顿之后再查询服务器,而不是每次按键都发送请求:这就是 防抖 ([debounce])。该 Hook 返回收到的值……但只有当它在 [delay] 毫秒内没有变化时才返回:

  • 第 17–20 行:每个新值都会重新启动副作用,副作用设置一个定时器;而上一次执行的清理会取消上一个值的定时器。因此,只有最后一个、之后又有停顿的值才会到达 [setDebounced]。

该 Hook 是泛型的([<T>]):它适用于任何类型的值。

5.1.3. 页面

// =========================================================================
// 19-asynchronous/src/App.tsx - 定时器、边输入边搜索、use()
// -------------------------------------------------------------------------
// 许多事情都发生在“以后”:定时器的滴答、
// 按键、服务器的响应。React 没有自己专门的
// 异步工具(Angular 使用 RxJS 库):我们把
// 状态、副作用及其清理组合起来,封装在 Hook 中(hooks/),
// 并且从 React 19 开始,用 use() + <Suspense> 来等待 promise。
// =========================================================================

import { Suspense, use, useEffect, useState } from 'react';
import { useCountdown } from './hooks/useCountdown';
import { useDebouncedValue } from './hooks/useDebouncedValue';

const DOCTORS = ['Marie PELISSIER', 'Paul TATOU', 'Sophie DUPONT', 'Jacques DURAND', 'Martine PELLETIER'];

// 一个模拟的“服务器”:响应在随机延迟之后到达
function search(text: string): Promise<string[]> {
  const found = DOCTORS.filter((m) => m.toLowerCase().includes(text));
  return new Promise((resolve) => setTimeout(() => resolve(found), 200 + Math.random() * 600));
}

// 3. 一个 promise,只创建一次(在组件之外):它在
// 一秒后解析
const messagePromise = new Promise<string>((resolve) =>
  setTimeout(() => resolve('three (one second later)'), 1000),
);

// use(promise):promise 的值。只要它尚未
// 解析,组件就会“挂起”它的显示:最近的 <Suspense>
// 转而显示它的等待内容(fallback)
function Message({ promise }: { promise: Promise<string> }) {
  const value = use(promise);
  return <p className="mb-0">received: {value}</p>;
}

export default function App() {
  const [log, setLog] = useState<string[]>([]);
  const trace = (message: string) => setLog((j) => [...j, `${new Date().toLocaleTimeString()} ${message}`]);

  // 1. 倒计时:一个自制的 Hook
  const countdown = useCountdown(20);

  // 2. 边输入边搜索
  const [input, setInput] = useState('');
  const text = useDebouncedValue(input.trim().toLowerCase(), 400); // 在 400 毫秒内没有按键之后
  const [results, setResults] = useState<string[]>([]);

  useEffect(() => {
    if (text.length < 2) {
      return; // 不搜索(也没有清理)
    }
    // “过期”:在另一次搜索开始之后才到达的响应
    // 必须被忽略(否则,旧搜索的慢响应
    // 会覆盖新搜索的响应)
    let stale = false;
    trace(`search sent: "${text}"`);
    search(text).then((found) => {
      if (stale) {
        trace(`response ignored (stale): "${text}"`);
        return;
      }
      setResults(found);
    });
    // 清理:当 text 变化(新的搜索)或组件被移除时执行
    return () => {
      stale = true;
    };
  }, [text]);

  // 少于两个字母:没有结果,不管上一次
  // 搜索的结果如何(一个计算值,而不是多一个状态)
  const displayed = text.length < 2 ? [] : results;

  return (
    <div className="container py-4" style={{ maxWidth: 720 }}>
      <h1 className="h3 mb-3">Example 19 - asynchrony</h1>

      <div className="card p-3 mb-3">
        <h2 className="h6">A countdown (setInterval in a hook)</h2>
        <p className="display-6 mb-0">{countdown}</p>
      </div>

      <div className="card p-3 mb-3">
        <h2 className="h6">A search as you type (debounce, stale responses)</h2>
        <input className="form-control mb-2" placeholder="at least two letters: pel, dur..." value={input}
               onChange={(e) => setInput(e.target.value)} />
        <ul className="mb-0">
          {displayed.map((r) => <li key={r}>{r}</li>)}
          {displayed.length === 0 && <li className="text-muted">no result</li>}
        </ul>
      </div>

      <div className="card p-3 mb-3">
        <h2 className="h6">Waiting for a promise (use and Suspense)</h2>
        <Suspense fallback={<p className="text-muted mb-0">waiting...</p>}>
          <Message promise={messagePromise} />
        </Suspense>
      </div>

      <h2 className="h6">Log</h2>
      <ol className="small">
        {log.map((line, i) => <li key={i}>{line}</li>)}
      </ol>
    </div>
  );
}
  • 第 18–21 行:一个模拟的“服务器”:响应在 200 到 800 毫秒的随机延迟之后到达;
  • 第 25–27 行:一个 promise,只创建一次(在组件之外),一秒后解析;
  • 第 32–35 行:[use(promise)] 返回 promise 的值。只要它尚未解析,组件就会“挂起”它的显示:最近的 [<Suspense>] (第 96 行)显示它的占位内容([fallback])。promise 解析之后,[React] 重新调用组件,而 [use] 返回该值。promise 必须在组件之外创建,或者由缓存它的库创建:在渲染期间创建的 promise 每次调用都会被重新创建,等待将永远不会结束;
  • 第 42 行:自定义 Hook;
  • 第 46 行:搜索文本,在 400 毫秒内没有按键之后得到;
  • 第 49–69 行:搜索,当(经过防抖的)文本变化时重新启动:
    • 过期响应的问题:你输入“pel”,停顿,搜索开始;你再输入“du”,停顿,第二次搜索开始。如果“pel”的响应在“du”的响应之后才到达(网络延迟不可预测),它就会覆盖正确的结果;
    • 解决办法(第 56–67 行):为副作用的每一次执行设置一个专属的变量,当文本变化时把它重置为 [true] 。之后到达的任何响应都会被忽略;
  • 第 73 行:少于两个字母:没有结果,不管上一次搜索的结果如何。这是一个计算值,而不是额外的状态。

你输入“pel”,稍等片刻,再输入“du”;“pel”的响应到达得太晚,被忽略了:

Image

自己编写查询处理代码(进行中、成功、错误、过期、已在缓存中等等)既繁琐又枯燥。要与服务器通信,实践中会使用一个替你处理这些的库:在示例 24 中,它将是 [TanStack Query]。

5.2. 示例 20:共享状态

示例 18 展示了如何手工编写一个 store。[Zustand] 库只需几行就能完成同样的事情,它是在 [React] 应用中管理共享状态最常用的库之一(另一个是 [Redux Toolkit],它更全面,但也更耗资源)。

5.2.1. 购物车

// =========================================================================
// 20-shared-state/src/stores/cart.ts - 使用 Zustand 的共享状态
// -------------------------------------------------------------------------
// “store”是存在于组件之外的状态,只有一份
// 副本,由所有读取它的组件共享。示例 18 手工编写了
// 一个(useSyncExternalStore);Zustand 库只用几行就完成了
// 同样的事情:
//
//     const useCart = create<Cart>()((set, get) => ({ ...state and actions... }));
//
// create 返回一个 Hook。组件通过“选择器”从中读取它需要的内容:
// useCart((p) => p.items)。只有当这部分状态变化时
// 组件才会被再次调用。常见的组织方式:
//   - 状态:数据(items);
//   - action:函数,是唯一通过 set() 修改状态的方式;
//   - 计算值:函数(或选择器)。
// store 与应用同生共死:它不会因组件被
// 移除而消失……但页面重新加载(F5)会使它消失,因为那会重新启动
// 应用。(上下文加 useReducer 也能完成同样的工作;
// store 的优点是在组件之外也可读取。)
// =========================================================================

import { create } from 'zustand';

export interface Item {
  label: string;
  price: number;
}

interface Cart {
  items: Item[];
  add: (item: Item) => void;
  clear: () => void;
}

export const useCart = create<Cart>()((set) => ({
  items: [],
  // set(function):接收当前状态,返回要改变的部分(其余保持不变)
  add: (item) => set((p) => ({ items: [...p.items, item] })),
  clear: () => set({ items: [] }),
}));

// 可复用的选择器:由状态计算得出的值
export const itemCount = (p: Cart) => p.items.length;
export const cartTotal = (p: Cart) => p.items.reduce((s, a) => s + a.price, 0);
  • 第 23 行:创建 store 的函数;
  • 第 30–34 行:store 的类型:状态 ([items])和 action ([add]、[clear]),只有 action 才能修改它;
  • 第 36–41 行:[create<Cart>()(factory)] 创建 store 并返回一个 Hook。工厂函数接收 [set],用它来修改状态:[set(object)] 或 [set((state) => object)];只需传入发生变化的部分,其余部分保持不变。与 [useState] 一样,状态本身从不被修改:而是创建一个新的状态;
  • 第 44–45 行:选择器——根据状态计算出一个值的函数。

store 在应用运行期间始终存在,且只有一份:它不会因组件被移除而消失……但页面重新加载(F5)会使它消失,因为那会重新启动应用。上下文加 [useReducer] 也能完成同样的工作;store 有两个优点:它在组件之外也可读取(例如由路由守卫读取),并且只有当组件读取的那部分状态发生变化时,才会回调该组件。

5.2.2. 偏好设置

// =========================================================================
// 20-shared-state/src/stores/preferences.ts - 刷新(F5)后仍然保留的状态
// -------------------------------------------------------------------------
// 要让数据在页面重新加载或关闭浏览器后仍然保留,就必须把它存放在浏览器中
// :localStorage(一个
// 键 -> 字符串的小字典,每个站点各自独立)。
// Zustand 的 persist“中间件”负责这件事:它在创建 store 时重新读取 localStorage
// ,并在每次变化时重写它(键
// "example20.preferences",值:状态的 JSON)。
// 切勿在其中存放敏感数据(密码、令牌):
// 页面中的任何脚本都能读取 localStorage。
// =========================================================================

import { create } from 'zustand';
import { persist } from 'zustand/middleware';

interface Preferences {
  dark: boolean;
  size: number; // 文字大小,单位 px
  update: (change: Partial<Pick<Preferences, 'dark' | 'size'>>) => void;
}

export const usePreferences = create<Preferences>()(
  persist(
    (set) => ({
      dark: false,
      size: 16,
      update: (change) => set(change),
    }),
    { name: 'example20.preferences' },
  ),
);

要让数据在页面重新加载或浏览器关闭之后仍然保留,就必须把它存放在浏览器中:[localStorage],一个每个站点各自独有的、由键和字符串组成的小型字典。[Zustand] 的“中间件” [persist] 负责处理这件事(第 24–31 行):它在创建 store 时读取 [localStorage] ,并在每次发生变化时,以键 [example20.preferences] (第 30 行)重新写入。敏感数据(密码、令牌)绝不存放在那里:页面上的任何脚本都可以读取 [localStorage]。

5.2.3. 组件

// 20-shared-state/src/components/Shop.tsx - 向共享购物车中添加商品
import { useCart, type Item } from '../stores/cart';

const PRODUCTS: Item[] = [
  { label: 'Consultation', price: 30 },
  { label: 'Vaccine', price: 12.5 },
];

export default function Shop() {
  // 只读取 action:购物车变化时,Shop 不会被再次调用
  const add = useCart((p) => p.add);
  return (
    <div className="card p-3 h-100">
      <h2 className="h6">Shop</h2>
      {PRODUCTS.map((p) => (
        <button key={p.label} className="btn btn-sm btn-outline-primary mb-2" onClick={() => add(p)}>
          + {p.label} (€{p.price})
        </button>
      ))}
    </div>
  );
}

[useCart((p) => p.add)]:组件通过 选择器 读取 store,并且只有它所读取的那部分状态发生变化时才会被调用。[Shop] 只读取 action [add],它永远不变:因此购物车变化时它从不被调用。

// 20-shared-state/src/components/CartSummary.tsx - 读取同一个购物车
import { itemCount, cartTotal, useCart } from '../stores/cart';

export default function CartSummary() {
  const count = useCart(itemCount);
  const total = useCart(cartTotal);
  const clear = useCart((p) => p.clear);
  return (
    <div className="card p-3 h-100">
      <h2 className="h6">Cart</h2>
      <p className="mb-2">{count} item(s), €{total}</p>
      <button className="btn btn-sm btn-outline-danger align-self-start" disabled={count === 0} onClick={clear}>Clear</button>
    </div>
  );
}

[CartSummary] 使用 store 的选择器读取商品数量和总额。

// 20-shared-state/src/components/LocalCounter.tsx - 一个本地状态,随组件一起消失
import { useState } from 'react';

export default function LocalCounter({ title }: { title: string }) {
  const [clicks, setClicks] = useState(0);
  return (
    <div className="card p-3 h-100">
      <h2 className="h6">{title}</h2>
      <button className="btn btn-sm btn-outline-secondary align-self-start" onClick={() => setClicks(clicks + 1)}>
        {clicks} click(s)
      </button>
    </div>
  );
}

一个本地状态,它会随组件一起消失。

5.2.4. 页面

// =========================================================================
// 20-shared-state/src/App.tsx - 客户端数据的三种“作用域”
// -------------------------------------------------------------------------
// 与 NestJS 课程的示例 23 是同一个问题(应用、请求、
// 客户端作用域),只是搬到了浏览器中:
//   - 组件的本地状态(LocalCounter)随组件一起消失;
//   - STORE 的状态(购物车)由所有组件共享
//     ,组件被移除后依然存在,但刷新(F5)后会丢失;
//   - 保存在 localStorage 中的状态(偏好设置)在刷新(F5)和
//     关闭浏览器后依然保留。
// 还有 React 19.2 的新特性 <Activity mode="hidden">:内容被
// 隐藏,但并未移除,其本地状态得以保留。
// 取消勾选再重新勾选“显示该区域”,然后重新加载页面:对比一下效果。
// =========================================================================

import { Activity, useState } from 'react';
import { usePreferences } from './stores/preferences';
import Shop from './components/Shop';
import CartSummary from './components/CartSummary';
import LocalCounter from './components/LocalCounter';

export default function App() {
  const { dark, size, update } = usePreferences();
  const [areaVisible, setAreaVisible] = useState(true);

  return (
    <div className={`min-vh-100 ${dark ? 'bg-dark text-light' : ''}`} style={{ fontSize: size }}>
      <div className="container py-4">
        <h1 className="h3 mb-3">Example 20 - a shared state</h1>
        <div className="d-flex flex-wrap gap-4 mb-3">
          <label className="form-check-label">
            <input type="checkbox" className="form-check-input" checked={dark}
                   onChange={(e) => update({ dark: e.target.checked })} /> dark theme
          </label>
          <label>
            text size{' '}
            <input type="range" min={12} max={22} value={size}
                   onChange={(e) => update({ size: e.target.valueAsNumber })} /> {size} px
          </label>
          <label className="form-check-label">
            <input type="checkbox" className="form-check-input" checked={areaVisible}
                   onChange={(e) => setAreaVisible(e.target.checked)} /> show the area
          </label>
        </div>
        <div className="row g-3 text-body">
          {/* 已移除:这些组件连同其本地状态一起消失 */}
          {areaVisible && (
            <>
              <div className="col-md-3"><Shop /></div>
              <div className="col-md-3"><CartSummary /></div>
              <div className="col-md-3"><LocalCounter title="Local state" /></div>
            </>
          )}
          {/* 已隐藏:组件仍保留在内存中,其状态得以保留 */}
          <Activity mode={areaVisible ? 'visible' : 'hidden'}>
            <div className="col-md-3"><LocalCounter title="Local state, in an Activity" /></div>
          </Activity>
        </div>
        <p className="mt-3 mb-2">Outside the area, a second summary of the SAME cart (it stays there when the area disappears):</p>
        <div className="text-body"><CartSummary /></div>
      </div>
    </div>
  );
}
  • 第 23 行:没有选择器时,会读取整个 store(并且每次变化时组件都会被重新调用);
  • 第 47–53 行:取消勾选复选框时,该区域被 移除:它的组件随其本地状态一起消失;
  • 第 55–57 行:[<Activity mode="hidden">] ([React] 19.2)隐藏 它的内容而不移除它:组件及其状态仍保留在内存中。这对标签页或你离开后还会返回的页面很有用;
  • 第 60 行:在该区域之外,是同一个购物车的第二个摘要。

向购物车添加两件商品,双击第一个本地计数器,三击 [Activity] 中的那个计数器,取消勾选再重新勾选“显示该区域”,并勾选“深色主题”:

Image

购物车保持完整(它在 store 中);第一个计数器已重置为 0(它的组件被移除后又被重新创建);[Activity] 中的那个保留了它的值。重新加载页面(F5)时,购物车为空,但主题和文字大小被保留([localStorage])。

这与 [NestJS] 课程中的示例 23 是同一个问题(应用作用域、查询、客户端),只是移植到了浏览器中。