副作用与数据获取
本合集目录
本章目录
单册说明:本文件是卷 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",从而检查调用位置。
- 只能在组件或其他 hook 的顶层调用,不能写在
if、for、return之后; - 名字必须以
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;
}
三个设计决定:
- 用一个对象装四种状态,而不是
const [loading, setLoading]、const [error, setError]、const [data, setData]。分开写会出现"loading 已经 false 但 error 还没设"的中间态,界面闪一下空白。一个对象一次提交,永远自洽。 status用字符串而不是布尔组合。loading && !error && data.length === 0这种表达式迟早写错;一个枚举值,switch一写就穷尽。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('模拟失败'),显示"加载失败:模拟失败"。
复现竞态(必须做一次)
- 把
useNotes里的return () => controller.abort();注释掉; - 把
wait(600, signal)里的 600 改成1200 + Math.random() * 800,让每次请求耗时不同; - 快速点两个标签,来回切三次;
- 观察列表内容和你最后点的标签对不上——有时会闪回上一个标签的数据。
把 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"的经典问题。