跳到正文
零到全栈 · 卷 4 · 从页面到应用

副作用与数据获取

本合集目录
本章目录

单册说明:本文件是卷 4 的第 4 章,可独立阅读。前置:第 3 章(状态与不可变更新)、卷 2 第 6 章(fetch 与 Promise)。本章只做一件事:把"从外面拿数据"这件脏活放进正确的位置,并让它可取消、不打架。

项 内容
所属卷 卷 4 · React 与 Next.js(第 4 / 8 章)
前置章节 4.3 状态与受控组件;2.6 异步:fetch 与 Promise
本章产出 一个带 loading / error / empty / ready 四态的 useNotes hook
对应代码 src/hooks/useNotes.js、src/api/notes.js
配图 无(后续统一制图)
读完的判定 能解释"快速切页为什么会让旧结果盖掉新的",并写出两种防法

4.4.1 一句话结论:渲染只算界面,凡是要"和外面打交道"的都放 effect

先看一段几乎人人都写过、也几乎人人都会写错的代码:

export default function NotesPage() {
  const [notes, setNotes] = useState([]);
  fetch('/api/notes')
    .then((r) => r.json())
    .then(setNotes);

  return <NoteList notes={notes} />;
}

看起来只是"取个数据",实际会发生什么:请求返回 → setNotes → 重渲染 → 又执行一次 fetch → 又 setNotes……Network 面板里请求一条接一条地刷,最后控制台出现:

Maximum update depth exceeded. This can happen when a component repeatedly calls setState inside componentWillUpdate or componentDidUpdate. React limits the number of nested updates to prevent infinite loops.

这不是网络问题,也不是接口问题,是你把副作用写在了渲染里。

用大白话说:副作用就是"算这次界面之外,还顺手改变了世界"。 改一个局部变量不算(那只是计算),发请求、开定时器、写磁盘、改 document.title,都算。React 要求渲染只做计算,是因为它需要在心里"预演"界面——预演的时候不能真的把请求发出去。

4.4.2 原理与方法

渲染必须是纯的

"纯"在编程里的意思很具体:同样的输入,永远得到同样的输出,且不改变外部世界。React 假设你的组件函数是纯的,因此它敢做这些事:在开发环境执行两次、在需要时丢弃某次结果、并发地准备多个版本。

放在渲染里没问题 必须放进 effect 或事件处理
读 props / state 发请求
计算、过滤、格式化 改 document.title、操作 DOM
map 出新数组 写 localStorage
调用纯函数(日期格式化、校验) 订阅事件、开定时器
创建 JSX 元素 打日志上报、初始化第三方图表

判断方法:"这句话执行两次会不会出问题?" 会,就不是纯的。array.sort() 会(改了 props),localStorage.setItem 会(多写一次倒是无害,但它在 StrictMode 下会写两遍,容易误导),fetch 更会。

useEffect 是什么

useEffect(() => {
  // 渲染提交到 DOM 之后执行
  return () => {
    // 清理:组件卸载前,或下一次 effect 执行前
  };
}, [依赖]);

执行时序要记准:

组件函数执行(渲染)
  → React 把结果提交到 DOM
  → 浏览器绘制
  → 执行 effect

所以 effect 里拿到的 DOM 已经是更新后的。这也是为什么"测量元素高度""初始化图表"必须放这里,放在函数体里量到的是旧 DOM。

依赖数组的三种形态

写法 执行时机 典型用途 风险
不传 每次渲染后都执行 几乎不用 effect 里 setState → 无限循环
[] 挂载后一次 只取一次初始数据、订阅全局事件 拿不到后续 props 变化,容易闭包旧值
[a, b] a 或 b 变化时(Object.is 比较) 按条件重新同步 漏依赖 → 用到旧值;放对象 → 每次都"变了"

"漏依赖"的经典表现:

useEffect(() => {
  load(tag);
}, []);          // tag 变了,但 effect 不会再跑

切换标签,列表纹丝不动。ESLint 的 react-hooks/exhaustive-deps 会直接点出来:

React Hook useEffect has a missing dependency: 'tag'. Either include it or remove the dependency array.

这条提示不要关。它是这一章最有价值的工具。

清理函数:不只为了"卸载"

清理在两种时机执行:组件卸载前,以及下一次 effect 执行前。第二种更常被忽略。

useEffect(() => {
  const id = setInterval(() => setTick((t) => t + 1), 1000);
  return () => clearInterval(id);
}, []);

不写 return 会发生什么:

资源 不清理的后果
setInterval 定时器叠加:切一次页面多一个,1 秒跳 2 下、3 下、越来越快
addEventListener 同一个回调被注册多次,一次点击触发 N 次
WebSocket / 订阅 连接泄漏,服务端看到一堆僵尸客户端
请求 结果回来时组件已经卸载,或者覆盖了新页面的数据

React 18 之后,"在已卸载组件上 setState"不再打印警告了。这意味着你连提示都没有了,只能靠现象判断:内存涨、请求翻倍、数据错乱。

竞态:快速切页时,旧结果会盖掉新的

这是本章最值钱的一节。时序如下:

时刻 动作 界面状态
0 ms 点开摘录 A,请求要 900 ms loading
100 ms 觉得不对,改点 B,请求只要 80 ms loading
180 ms B 返回 显示 B
900 ms A 返回,setNote(A) 显示 A 的标题 + A 的正文

用户看到的是:URL 是 B,内容却是 A。他不会报 bug,他只会觉得"这个网站数据是错的"。

两个修法,都要会。

修法一:取消请求(AbortController)。

useEffect(() => {
  const controller = new AbortController();
  setStatus('loading');

  fetchNote(id, { signal: controller.signal })
    .then((data) => {
      setNote(data);
      setStatus('ready');
    })
    .catch((err) => {
      if (err.name === 'AbortError') return;   // 主动取消,不算错误
      setError(err.message);
      setStatus('error');
    });

  return () => controller.abort();
}, [id]);

catch 里必须放过 AbortError。否则每次切页都会闪一下"加载失败",看起来像 bug。

修法二:丢弃过期结果(标记位)。

useEffect(() => {
  let ignored = false;

  load(id).then((data) => {
    if (ignored) return;
    setNote(data);
  });

  return () => { ignored = true; };
}, [id]);

为什么两种都要会:AbortController 只能取消支持 signal 的请求(fetch 支持,很多第三方 SDK 不支持);标记位则适用于任何 Promise。代价是请求还在跑,只是结果被丢掉——省不了流量,但能保证界面正确。

有人会想:那我比较一下 id === 当前 id 不就行了?问题是 effect 里拿到的 id 是发起请求那一轮的值,它不会因为用户又点了一下就自动更新。你比较的仍然是旧值,结论永远是"我是最新的"。这就是闭包陷阱在异步场景里的样子。

StrictMode 下 effect 跑两次,是故意的

开发环境里,React 会做一次"挂载 → 卸载 → 再挂载",effect 因此执行两遍。真实表现:

  • Network 面板里同一个请求出现两条,其中一条状态是 (canceled);
  • 你在 effect 里打的日志出现两次;
  • 计数器初始化了两次。

它的目的是把"没清理干净"的 effect 暴露出来。如果你第一次请求没被取消,说明 cleanup 写漏了——这正是线上会出问题的地方。

必须强调:生产构建只执行一次。 不要为了消掉这两条日志去写 useRef 标记"只执行一次",那等于把体检报告撕了。

自定义 hook 的两条规矩

useNotes 是个普通函数,只是名字以 use 开头。这个前缀不是装饰:React 和 ESLint 靠它识别"这里面可能用了 hook",从而检查调用位置。

  1. 只能在组件或其他 hook 的顶层调用,不能写在 if、for、return 之后;
  2. 名字必须以 use 开头,否则工具不会检查它。

第一条的原因:React 靠调用顺序把每次渲染的 state 对上号。你在某个分支里少调用一个 hook,第二次渲染的顺序就错位了,状态会串到别的变量上——轻则数据莫名出错,重则直接报 Rendered more hooks than during the previous render.

什么时候根本不需要 useEffect

这一节能砍掉你未来一半的 effect。

需求 该放哪
根据 notes 和 tag 算出可见列表 渲染里直接算(派生)
点击按钮后提交、跳转 事件处理函数里
输入框的值 state + onChange
路由参数变了要重置表单 给组件加 key,让它重建
首次进入页面要取数据 effect(正当用途)
数据变了要同步到另一个 state 通常说明不该有第二个 state

"用 key 重置"值得展开一句:

<NoteForm key={editingId} note={note} />

editingId 一变,React 认为这是一个新组件,卸载旧的、挂载新的,内部 state 自动回到初始值。比在 effect 里逐个 setDraft 干净得多,也不会出现"先渲染一帧旧数据"的闪烁。

4.4.3 动手:四态取数 hook

假接口:先模拟延迟,卷 5 换成真 fetch

src/api/notes.js:

import { notes as seed } from '../data/notes';

function wait(ms, signal) {
  return new Promise((resolve, reject) => {
    const timer = setTimeout(resolve, ms);
    signal?.addEventListener('abort', () => {
      clearTimeout(timer);
      const err = new Error('请求已取消');
      err.name = 'AbortError';
      reject(err);
    }, { once: true });
  });
}

export async function fetchNotes({ tag = 'all', signal } = {}) {
  await wait(600, signal);
  const list = tag === 'all' ? seed : seed.filter((n) => n.tags.includes(tag));
  return list;
}

export async function fetchNote(id, { signal } = {}) {
  await wait(300, signal);
  const found = seed.find((n) => String(n.id) === String(id));
  if (!found) {
    const err = new Error('没有这条摘录');
    err.name = 'NotFoundError';
    throw err;
  }
  return found;
}

wait 里监听 abort 并 reject,是为了让假接口和真 fetch 的行为一致:取消时抛一个 name === 'AbortError' 的错误。这样你后面换成真接口,hook 一行都不用改。

hook:把四种状态收进一个对象

src/hooks/useNotes.js:

import { useEffect, useState } from 'react';
import { fetchNotes } from '../api/notes';

const initial = { status: 'loading', data: [], error: '' };

export function useNotes(tag) {
  const [state, setState] = useState(initial);

  useEffect(() => {
    const controller = new AbortController();
    setState(initial);

    fetchNotes({ tag, signal: controller.signal })
      .then((data) => {
        setState({
          status: data.length === 0 ? 'empty' : 'ready',
          data,
          error: '',
        });
      })
      .catch((err) => {
        if (err.name === 'AbortError') return;
        setState({ status: 'error', data: [], error: err.message });
      });

    return () => controller.abort();
  }, [tag]);

  return state;
}

三个设计决定:

  1. 用一个对象装四种状态,而不是 const [loading, setLoading]、const [error, setError]、const [data, setData]。分开写会出现"loading 已经 false 但 error 还没设"的中间态,界面闪一下空白。一个对象一次提交,永远自洽。
  2. status 用字符串而不是布尔组合。loading && !error && data.length === 0 这种表达式迟早写错;一个枚举值,switch 一写就穷尽。
  3. setState(initial) 在 effect 开头,保证切标签时立刻回到 loading,而不是先显示上一个标签的数据。

状态机长这样,四条边都堵上了:

        ┌──────────► ready(有数据)
loading ┤
        ├──────────► empty(请求成功但零条)
        └──────────► error(请求失败)

用起来

src/components/NotesView.jsx:

import { useNotes } from '../hooks/useNotes';
import NoteList from './NoteList';

export default function NotesView({ tag }) {
  const { status, data, error } = useNotes(tag);

  if (status === 'loading') return <p className="hint">加载中…</p>;
  if (status === 'error') return <p className="error">加载失败:{error}</p>;
  if (status === 'empty') return <p className="hint">这个标签下还没有摘录</p>;
  return <NoteList notes={data} />;
}

预期效果:切换标签后先显示"加载中…"约 0.6 秒,然后出现对应列表;选一个没有数据的标签,显示"这个标签下还没有摘录"而不是空白;把 fetchNotes 里改成 throw new Error('模拟失败'),显示"加载失败:模拟失败"。

复现竞态(必须做一次)

  1. 把 useNotes 里的 return () => controller.abort(); 注释掉;
  2. 把 wait(600, signal) 里的 600 改成 1200 + Math.random() * 800,让每次请求耗时不同;
  3. 快速点两个标签,来回切三次;
  4. 观察列表内容和你最后点的标签对不上——有时会闪回上一个标签的数据。

把 return 那行恢复,重复操作,错乱消失。

4.4.4 三个坑

坑一:依赖数组漏了变量,effect 里全是旧值

症状:切标签列表不变;或者 effect 里 console.log(tag) 永远打印第一次的值;或者请求发出去了,但带的是旧参数。

成因:[] 让 effect 只在挂载时执行一次。那次执行时闭包捕获了当时的 tag,之后组件重渲染了,effect 里的那个函数还是旧的。

修法:把 effect 里用到的所有响应式值(props、state、组件内定义的函数)都列进依赖。宁可多跑几次,也不要拿着旧值算。ESLint 的提示不要屏蔽,它就是在替你找这个 bug。

坑二:依赖里放了对象或数组字面量

症状:页面疯狂请求,Network 面板一秒几十条;控制台 Maximum update depth exceeded。

成因:Object.is({}, {}) 是 false。每次渲染 { tag } 都是一个新对象,React 认为依赖变了,于是重跑 effect;effect 里 setState 又触发渲染……

useEffect(() => { load({ tag }); }, [{ tag }]);   // 永远在变

修法:依赖只放原始值,[tag] 就够了。确实需要对象时,用 useMemo 固定引用,或者把对象构造移到组件外面。判断口诀:依赖数组里出现 {}、[]、内联函数,先怀疑。

坑三:忘了清理,定时器和请求越积越多

症状:倒计时越跳越快;离开页面后控制台还在打日志;切了五次标签,Network 里有五个未完成的请求。

一个真实场景:会话页每 3 秒轮询一次在线人数,用户来回切了五个会话,五个定时器同时在跑,请求量变成五倍,服务端日志里同一个用户出现五条一模一样的记录。

成因:useEffect 里的 setInterval、addEventListener、fetch 都没有对应的 return 清理。组件卸载了,它们还在跑。

修法:凡是"申请了一个资源",就写对应的释放。定时器 clearInterval,监听 removeEventListener(注意传同一个函数引用),请求 controller.abort()。写 effect 时养成习惯:先写 return,再写正文。

本章验收

  • 能列出至少四件"必须放 effect"和四件"不必放 effect"的事
  • 能说出依赖数组三种形态的语义,并解释漏依赖会导致什么现象
  • useNotes 四态齐全,切标签会先回到 loading
  • 亲手复现了一次竞态(旧结果覆盖新结果),并用 AbortController 修好
  • 能解释 StrictMode 下为什么请求发两次,以及为什么不该用 ref 绕过

自测

Q1:为什么"在 effect 里发请求"比"在组件函数体里发请求"正确?

看答案 函数体在每次渲染时都会执行,而渲染可能因为任何 state 变化发生,于是请求会被反复发出,并且 setState 又会触发新的渲染,形成循环。effect 只在依赖变化后执行,等于给"什么时候该请求"加了一个明确条件。另外 effect 在 DOM 提交后运行,能安全地读写 DOM。

Q2:useEffect(fn, []) 和 useEffect(fn) 有什么区别?各自的典型事故是什么?

看答案 不传依赖:每次渲染后都执行,如果 fn 里 setState,就会无限循环直到报 Maximum update depth exceeded。传空数组:只在挂载后执行一次,如果 fn 里用了会变化的 props/state,就会一直用旧值,表现为"参数改了但请求没重发"。前者是死循环,后者是静默错误,后者更难查。

Q3:已经用了 AbortController,为什么还需要"忽略过期结果"的标记位?

看答案 因为 abort 只能在请求支持 signal 时生效。第三方 SDK、读 localStorage 的假接口、已经进入 then 链的 Promise 都可能不响应取消信号。此时用 ignored 标记在回调里判断,能保证即使结果回来了也不写入状态。两者是"尽量取消"和"保证正确"的关系,不是二选一。

下一步

数据会取了,但整个应用还只有一个页面——所有内容都挤在 /。下一章把 URL 变成真正的状态:三条路由、一个共享布局,以及一个"刷新就 404"的经典问题。

→ 卷4-05-路由与页面组织.md