前年做一个商品搜索页,需求很简单:输入关键词,停顿一下再查,结果列在下面。第一版上线后客服转来一个反馈:搜“手机壳”,出来的全是“手机”。我以为是后端缓存,抓包看请求参数,kw 从头到尾都是同一个词,就是用户第一次进来时带在 URL 上的那个。
代码是这样的:
function SearchPage({ initialKeyword }) {
const [keyword, setKeyword] = useState(initialKeyword);
const [list, setList] = useState([]);
useEffect(() => {
fetch("/api/search?kw=" + encodeURIComponent(keyword))
.then((res) => res.json())
.then((data) => setList(data.list));
}, []); // 空数组:只跑一次
return (
<div>
<input
value={keyword}
onChange={(e) => setKeyword(e.target.value)}
/>
<ul>
{list.map((item) => <li key={item.id}>{item.name}</li>)}
</ul>
</div>
);
}
函数里的 keyword 每次输入都在变,屏幕上输入框里的字也确实在变,但那个请求只发了一次,闭包里留下的是第一次渲染时的 keyword。依赖数组写空,等于告诉 React“这个 effect 跟任何值都无关,永远别再执行”。
后来同事改成了依赖数组放整个筛选对象,结果更糟:每次渲染都发请求,因为那个对象是渲染时新建的,每次引用都不同。两个 bug 的根都在同一件事上:不知道依赖数组在比较什么。这篇就把 Hooks 里最容易出错的这几块拆开讲。
useState:它管的是“这次渲染的快照”
先用一句话把 useState 说准:它返回的当前值,是这次渲染时的那一份快照,整个函数体执行期间不会变。setKeyword("新词") 并不会把手上这个 keyword 变量改掉,它只是排了一次队,让 React 用新值重新渲染一遍。下一次渲染时,函数重新执行,拿到的才是新值。
所以“设置完立刻读”永远读到旧的。这不是异步延迟的问题,而是两次渲染之间本来就没有共享的可变变量。理解了这一点,很多看起来诡异的行为就正常了:循环里连续设置三次,三次都用的是同一个快照;在 alert 里读 state,弹出来的是点击那一刻渲染的值。
新值依赖旧值时,用函数式更新。这点上一篇讲过,这里补一个容易忽略的用法:惰性初始化。useState(() => buildFormFromProps(props)) 传函数进去,React 只会在首次渲染时调用它,后续重新渲染不会重复计算。如果直接写 useState(buildFormFromProps(props)),每次渲染都会白算一遍,数据量大时很明显。
还有一个常见误解:把 state 当成普通变量用,什么都往里塞。能在渲染时算出来的值不要存 state,比如“筛选后的列表”“是否全选”“总价”。存了两份,就一定有不同步的可能,而且你得额外写代码去同步。判断标准是:这个值能不能只由已有的 props 和 state 推导出来。能,就别存。
useEffect:它同步的是 React 之外的东西
useEffect 经常被当成“组件挂载后执行”来用,这个理解能用,但不够。它真正的作用是:在渲染之后,把 React 内部的状态同步到外部世界,或者反过来。外部世界包括网络、订阅、定时器、浏览器 API、第三方非 React 组件。这些事情发生在渲染之外,React 管不着,只能靠 effect 搭桥。
它执行的时机是在浏览器完成绘制之后,异步的,不阻塞渲染。effect 函数本身每次渲染都会重新创建,但执不执行、执行几次,由依赖数组决定。这一点很关键:不是每次渲染都跑 effect,而是每次渲染都重新判断要不要跑。
它不该干什么也要说清楚。点击按钮之后要发请求,就在事件处理函数里发,不要绕一圈设个 state 再让 effect 去发;能在一行里算出来的值,直接在渲染里算,不要用 effect 同步。把 effect 当成“万能钩子”,是项目里 effect 数量失控的主要原因。
清理函数:effect 的另一半
effect 可以返回一个函数,React 会在两种时机调用它:组件卸载时,以及依赖变化、下一次 effect 执行之前。清理的内容包括取消请求、清除定时器、解绑监听、关闭连接。写 effect 时我习惯先想“它留下了什么”,再想“怎么收回去”,不然迟早漏。
useEffect(() => {
const id = setInterval(() => {
checkStock();
}, 30000);
return () => clearInterval(id);
}, []);
请求的清理用 AbortController,它是浏览器原生能力,不需要装包。fetch 接收 signal,调用 abort() 后请求会被取消,catch 里拿到的错误 name 是 "AbortError",这种情况不要当成业务错误提示给用户。
useEffect(() => {
const controller = new AbortController();
fetch("/api/stock?sku=" + skuId, { signal: controller.signal })
.then((res) => res.json())
.then((data) => setStock(data))
.catch((err) => {
if (err.name !== "AbortError") setError("库存加载失败");
});
return () => controller.abort();
}, [skuId]);
然后是 StrictMode。React 18 的开发模式下,StrictMode 会把组件挂载、卸载、再挂载一次,effect 因此执行两次。很多人第一次看到两条请求会以为写错了,其实这是故意的:它在检查你的 effect 有没有正确清理。第一次执行留下的定时器、监听、请求,如果没有被清理函数收掉,第二次挂载后就会叠加,问题在开发阶段就暴露出来。
生产构建只会执行一次,可以用 npm run build 加 npm run preview 验证。不要为了消掉这两条请求去删 StrictMode,那等于把体检报告撕了。
派生状态不要用 effect 同步
下面这段代码在项目里非常常见,看起来也很合理,但它是个反模式:
function Price({ amountCents }) {
const [display, setDisplay] = useState(amountCents);
useEffect(() => {
setDisplay(amountCents); // 把 props 同步进 state
}, [amountCents]);
return <p>{display}</p>;
}
问题有三个。第一,多一次渲染:props 变了,先用旧值渲染一次,effect 改 state 后再渲染一次,界面上会闪一下旧价格。第二,出现两份真相,display 和 amountCents 可能不同步,尤其是依赖写漏的时候。第三,这段代码完全没有必要,因为 display 就是 amountCents 换了个名字。
正确做法是在渲染时直接算:const display = formatCents(amountCents);。如果这个计算确实很贵(比如要遍历上千条数据做聚合),用 useMemo 缓存,而不是用 state 加 effect。原则是:派生值不要落地成状态,状态只存“用户操作产生的、或者外部事件带来的”东西。
依赖数组写的是“effect 里用到的外部值”
依赖数组不是“我想让它什么时候跑”的开关,而是“这个 effect 依赖了哪些外部值”的声明。所谓外部值,指不在 effect 函数内部创建、而是从外面拿到的那些:props、state、组件里定义的函数和对象、来自上下文的引用。常量、模块级函数不需要写,因为它们永远不变。
漏写依赖的后果就是闭包过期:effect 里读到的是它创建那次渲染的值,之后再也不会更新。多写依赖的后果是 effect 多跑,不一定报错,但会浪费。更常见的是写错形式:把一个每次渲染都新建的对象放进去。
// 每次都跑:filters 是渲染时新建的对象
const filters = { status, page };
useEffect(() => {
load(filters);
}, [filters]);
// 只在 status 或 page 变化时跑
useEffect(() => {
load({ status, page });
}, [status, page]);
数组和函数同理。组件里写的 const handler = () => {...} 每次渲染都是新函数,放进依赖就会每次都触发。这也是 useCallback 存在的原因之一:它把函数引用稳定下来。但别为了消警告把所有函数都包一层,正确做法往往是让 effect 不依赖那个函数,比如把函数移到 effect 内部定义。
如果加了依赖之后变成无限请求,先别急着删依赖,先看 effect 里是不是在设置 state,而那个 state 又在依赖里。这种循环的本质是“用 effect 做派生”,回到上一节的处理方式就好。另一种循环是依赖里放了每次新建的对象,改成基本类型字段。
ESLint 的 exhaustive-deps 规则会提示漏写的依赖。我的建议是开着它,遇到提示先想清楚为什么,再决定加依赖还是改代码,不要一行注释关掉。
闭包过期:为什么请求永远带第一个关键词
回到开头那个搜索框。空依赖的 effect 只在首次渲染后执行一次,里面的 keyword 来自那一次渲染。后面用户怎么输入,setState 只是安排了新的渲染,旧的 effect 闭包不会重新创建,所以请求参数永远是第一次的值。这就是闭包在 Hooks 里的具体表现。
同样的坑还有监听器。下面这段代码注册一次 resize 监听,里面读 width,但回调是首次渲染创建的,之后永远打印初始宽度:
// 错的:回调里的 width 永远是初始值
useEffect(() => {
function onResize() {
console.log(width);
}
window.addEventListener("resize", onResize);
return () => window.removeEventListener("resize", onResize);
}, []);
修法有两种。第一种是把依赖写对,[width],这样宽度变了会重新注册监听,代价是注册解绑比较频繁。第二种是让回调不依赖那个值,改为在回调里直接读 window.innerWidth,依赖数组就可以是空的。第三种是用 ref 存最新值,回调读 ref.current,既不用重注册,也不会过期,下一节讲。
顺带说一句异步。多个请求并行时,除了参数过期,还有顺序问题:先发的请求慢、后发的快,后到的旧结果会覆盖新结果。取消能解决大部分,AbortController 一调用,旧请求直接不会回来;取消不了的情况(比如对方不支持),就要靠一个标记位或请求序号来判断“这个结果是不是已经过期”。这块和 Promise 与异步流程里的竞态是同一类问题。
useRef、useMemo、useCallback 各自解决什么
这三个 hook 经常被混在一起背,其实各自解决的问题完全不同。ref 解决“需要一个跨渲染稳定、但改了不想触发渲染的盒子”;memo 解决“这个计算很贵,别每次重算”;callback 解决“这个函数引用要稳定,别让依赖它的人反复执行”。
useRef:不触发渲染的盒子
useRef(initialValue) 返回一个对象,结构是 { current: initialValue },这个对象在组件的整个生命周期里是同一个。改 current 不会触发渲染,所以它适合放三类东西:DOM 节点引用、定时器或请求控制器的 id、以及“我只需要知道最新值但界面不关心”的数据。
function SearchBox() {
const inputRef = useRef(null);
const latestKeyword = useRef("");
useEffect(() => {
latestKeyword.current = keyword; // 每次渲染后更新,不触发渲染
});
function focusInput() {
inputRef.current.focus(); // 直接操作 DOM
}
return <input ref={inputRef} onChange={...} />;
}
注意第二个 effect 没有依赖数组,意思是每次渲染后都同步一次 ref,这是刻意的。不要在渲染过程中读写 ref.current 来做判断,那会让渲染产生副作用,React 也不保证顺序。ref 的初值只在首次渲染时用,后面再传不同的值不会更新。
useMemo 与 useCallback:缓存的是值,不是“性能”
useMemo(fn, deps) 在依赖不变时返回上一次的计算结果,依赖变了就重新算。useCallback(fn, deps) 是它的函数版本,依赖不变时返回同一个函数引用。两者都不是“加了就变快”,恰恰相反,它们本身有比较依赖和执行缓存逻辑的开销。
什么时候该用 useMemo:计算确实贵,比如对上千条数据排序、过滤、聚合;或者计算结果要作为另一个 hook 的依赖,需要引用稳定。什么时候不该用:一次 a + b、一次字符串拼接、一次几行的 filter,包一层只会让代码更难读。
useCallback 单独用几乎没有意义。它只有在两个场景下划算:传给用 React.memo 包过的子组件,避免子组件因为函数引用变化而重渲染;或者这个函数本身是某个 effect 的依赖,需要稳定。如果这两条都不满足,直接写普通函数就好。
什么时候抽自定义 hook
自定义 hook 就是一个以 use 开头、内部调用了其他 hook 的函数。它解决的是“逻辑复用”,不是“状态共享”。这一点最容易被误解:两个组件调用同一个 useSearch,各自会拿到独立的 state 和独立的 effect,不会共享任何东西。想共享状态,得用状态提升或上下文,不是抽 hook。
抽的时机我定得很死:同样的状态加 effect 组合在第二个地方真实出现了,再抽。只有一处用的时候抽出来,参数往往围绕当前场景长,换个场景就得加开关,最后变成一个什么都管的巨型 hook。抽出来之后,输入输出要写清楚,依赖要显式,不要把一堆隐式约定藏进去。
完整场景走查:搜索页从坏到好
需求整理一下:输入停顿 300 毫秒再发请求;连续输入时旧请求要取消;旧结果不能覆盖新结果;有加载中、空结果、出错三种状态;关键词同步到地址栏,刷新后能恢复。后端接口是 GET /api/search?kw=,返回 { list: [...] }。
第一版的问题在前面已经看到了:空依赖导致永远搜第一个词;没有清理,切走页面后请求还在飞;加载态在输入事件里直接设置,每敲一个字符闪一次;结果回来没有过期判断,快速输入时会被旧结果覆盖;错误直接被吞掉,用户只看到空白。
第二版把两段逻辑抽成 hook。第一个负责防抖,第二个负责请求和状态:
function useDebounced(value, delay = 300) {
const [debounced, setDebounced] = useState(value);
useEffect(() => {
const timer = setTimeout(() => setDebounced(value), delay);
return () => clearTimeout(timer);
}, [value, delay]);
return debounced;
}
它依赖 value 和 delay,每次输入都会清掉上一个定时器,只有停顿超过 300 毫秒才真正更新 debounced。首次渲染时 debounced 的初值就是当前 value,不会多发一次空请求。
function useSearch(keyword) {
const [state, setState] = useState({
status: "idle",
list: [],
error: ""
});
useEffect(() => {
if (!keyword) {
setState({ status: "idle", list: [], error: "" });
return;
}
let ignore = false;
const controller = new AbortController();
setState((prev) => ({ ...prev, status: "loading", error: "" }));
fetch("/api/search?kw=" + encodeURIComponent(keyword), {
signal: controller.signal
})
.then((res) => {
if (!res.ok) throw new Error("HTTP " + res.status);
return res.json();
})
.then((data) => {
if (!ignore) {
setState({ status: "done", list: data.list, error: "" });
}
})
.catch((err) => {
if (ignore || err.name === "AbortError") return;
setState({ status: "error", list: [], error: err.message });
});
return () => {
ignore = true;
controller.abort();
};
}, [keyword]);
return state;
}
这里有三个关键点。keyword 是唯一依赖,effect 里用到的其他东西要么在内部创建,要么是模块级常量。ignore 和 abort 一起用,前者挡住已经过期的回调,后者真正把连接断掉,节省后端资源。清理函数在依赖变化和卸载时都会执行,所以切换页面后不会有迟到的 setState。
页面组件只负责组装和渲染:
function SearchPage() {
const [keyword, setKeyword] = useState("");
const debounced = useDebounced(keyword, 300);
const { status, list, error } = useSearch(debounced);
return (
<div>
<input
value={keyword}
onChange={(e) => setKeyword(e.target.value)}
placeholder="搜索商品"
/>
{status === "loading" ? <p>搜索中</p> : null}
{status === "error" ? <p>{error}</p> : null}
{status === "idle" ? <p>输入关键词开始搜索</p> : null}
{status === "done" && list.length === 0 ? <p>没有找到相关商品</p> : null}
<ul>
{list.map((item) => (
<li key={item.id}>{item.name}</li>
))}
</ul>
</div>
);
}
在 StrictMode 下,useDebounced 的 effect 会执行两次,但第一次的定时器在清理函数里被清掉了,所以最终只会有一个更新;useSearch 的 effect 同理,第一次的请求会被 abort。开发环境看到两条请求不用改代码,生产构建只有一条。
还有一件事是 URL 同步。把关键词写进地址栏属于“同步到外部世界”,用 effect 是合理的,它确实需要监听 debounced 变化,然后调用 history.replaceState。这类操作不要放在渲染里,因为渲染函数应该是纯的。
最后看数量:第一版每敲一个字发一次请求,六字关键词六次;加防抖后通常剩一次;取消让快速输入时的无效请求不再占后端;空结果和错误各有提示,客服工单少了一半左右。
错误现象对照
Hooks 的问题有个共同点:代码看着没毛病,表现却不对。下面这张表按“看到什么、真实原因、先查哪里”整理,基本覆盖了日常能遇到的大部分:
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
| 输入新词,请求参数永远是第一次的值 | effect 依赖数组为空,闭包捕获了首次渲染的 state | 看 effect 里引用了哪些外部值,依赖数组是否都写上了 |
| 每次渲染都发请求,防抖像没生效 | 防抖函数在渲染过程中被反复创建,每次都是新的闭包 | 看 debounce(...) 写在哪,是否在组件函数体里直接调用 |
| 加了依赖之后请求停不下来 | 依赖里放了每次新建的对象或内联函数 | 把依赖项逐个打印出来,比较两次渲染的引用是否相同 |
| 开发环境同一条请求发两次 | StrictMode 故意挂载两次,用来检查 effect 清理 | 用生产构建再验一次;检查清理函数是否真的生效 |
| 切走页面后控制台警告或报错 | 请求回来时组件已卸载,清理函数缺失或没取消请求 | 看 effect 有没有返回清理函数,请求是否带 signal |
| 加载态一直转圈,结果不出现 | 某个分支提前 return,忘了把状态改回;或旧请求被忽略后没人接手 | 在每个 setState 分支打日志,确认最后一次更新是什么 |
| 窗口缩放后读到的宽度一直是初始值 | 监听回调注册一次,闭包里是首次渲染的变量 | 看注册监听的 effect 依赖,或改成在回调里读 window.innerWidth |
表格里没有“useMemo 让页面变慢”这一条,因为它的代价通常不是性能,而是可读性和维护成本。真正拖慢页面的是渲染了大量不该渲染的节点,memo 省不了这个。
边界与代价
useEffect 不是默认选项,它有几个实打实的成本。第一,它多一次渲染后的执行,数据流变成“渲染、effect、setState、再渲染”,链路变长,出问题时要在两次渲染之间找因果。第二,它让组件与外部世界耦合,测试要 mock 网络或浏览器 API。第三,依赖数组是手写的,写错不报错,只表现为行为异常。所以能用事件处理函数解决的,不要用 effect;能在渲染里算的,不要用 effect。
useMemo 和 useCallback 的成本也要说清楚:每个都要保存上一次的值和依赖,每次渲染都要做一次浅比较,代码里到处包一层还会打断阅读节奏。我见过一个组件包了十七个 useCallback,十五个只是转发参数,删掉后代码短一半,性能没变化。
自定义 hook 的代价是抽象泄漏。两个场景看起来像,实际规则不同,hook 就会不断增加参数和分支,最后变成一个没人敢改的黑盒。抽的时候问一句:这两个地方将来会不会因为业务原因分道扬镳?会,就别抽。
规模上的判断:一个组件里有五个以上 effect,基本该按职责拆开了;useCallback 的依赖链超过三层,说明函数在组件树里被反复传递,该考虑把逻辑下沉到 hook 或状态层;一个页面的请求超过四个且互相有依赖,该上请求库统一管理缓存和重试,而不是继续堆 effect。
什么时候不该用这套东西:只是把 props 换个形式存进 state;只是为了“组件挂载时执行一次”而套 effect,实际上可以在事件里做;或者为了消除 lint 警告而机械地补依赖。这三种做法只让代码更像规范,却更难懂。
小结
下面几条当天就能自己验证,建议按顺序做:
- 写一个
useDebounced,在延迟更新的 effect 里打印时间戳,快速输入五次,确认只输出一次。 - 把某个请求 effect 的依赖改成空数组,在请求 URL 里打印关键词,反复输入,观察参数是否一直不变;再改成
[keyword]对比。 - 写一个 resize 监听,用空依赖读
window.innerWidth存进 state,缩放窗口看值是否不变;再用正确依赖或 ref 修好。 - 在 StrictMode 下数 effect 执行次数和请求条数,然后
npm run build配合npm run preview再数一次。 - 把搜索页的 catch 分支改成断网测试,确认错误提示会出现,恢复网络后能重新搜索。
到这里,React 的状态模型算是走完一圈:状态怎么存、怎么改、怎么和外部世界同步、依赖怎么写。它的特点是显式——依赖由你手写,闭包由你判断,清理由你负责。下一篇换一个框架看同样的需求:Vue 起步:模板、响应式与组合式 API。Vue 3 用 Proxy 做依赖收集,effect 会自动追踪用到的响应式数据,所以几乎不会出现“依赖数组写漏”这类 bug;但解构丢响应式、ref 与 reactive 的选择又是它自己的坑。两套模型对照着看,你对“状态和视图怎么连起来”的理解会清楚很多。