03.4.1.2 Hooks 与状态
所属:全栈开发面试题库 / 03 前端基础与 Web 开发 / 03.4 前端框架 / 03.4.1 React
03.4.1.2-001 Hooks 是什么,解决了什么问题?
一句话结论
Hooks 是让函数组件接入状态、副作用与 React 内部能力的函数;它把跨组件复用的逻辑抽成自定义 Hook,替代类组件的生命周期与高阶组件/渲染属性等复用模式。
概念解释
- 内置 Hook:
useState、useEffect、useRef、useMemo、useCallback等。 - 自定义 Hook 以
use开头,封装可复用逻辑。 - Hooks 只能在函数组件或其他 Hook 顶层调用。
原理流程
- 组件渲染时按调用顺序读取对应 Hook 状态。
- Hook 返回当前值与更新入口。
- 更新触发重新渲染,Hook 状态沿顺序重新匹配。
代码 / 示例
function Counter() {
const [count, setCount] = useState(0);
return <button onClick={() => setCount((c) => c + 1)}>{count}</button>;
}
常见误区
- 误区:Hook 是函数组件里的普通工具函数;正解:Hook 依赖 React 按调用顺序保存的内部状态,不能随意抽取为普通函数。
- 误区:类组件也能调用 useState;正解:Hooks 只在函数组件与自定义 Hook 中使用。
追问
- Q:Hooks 替代了类组件哪些能力? A:状态、生命周期副作用、实例值、上下文订阅等,通过对应 Hook 实现。
- Q:自定义 Hook 之间如何共享状态? A:每次调用 Hook 都是独立状态实例,共享需配合 Context。
03.4.1.2-002 useState 如何工作?函数式更新解决什么问题?
一句话结论
useState 返回当前状态值与更新函数;更新可传新值或基于旧值的函数;函数式更新在闭包或连续更新场景下拿到最新状态,避免读到过期值。
概念解释
- 状态保存在 Fiber 节点上,跨渲染保留。
- 直接传值:以本次传入为准。
- 函数式更新:
setState(prev => prev + 1),基于队列中前一个状态计算。
原理流程
- 首次渲染用初始值建立状态。
- 调用更新函数排入更新队列。
- 重新渲染时按队列计算最新状态。
代码 / 示例
const [count, setCount] = useState(0);
// 闭包/连续点击场景用函数式更新
const onClick = () => setCount((prev) => prev + 1);
常见误区
- 误区:setState 后立刻能读到新值;正解:state 在当前渲染闭包中仍是旧值,下一次渲染才更新。
- 误区:连续多次
setCount(count + 1)会累加;正解:基于过期闭包值会被覆盖,需函数式更新。
追问
- Q:对象状态更新必须整体替换吗? A:是的,需复制旧对象再覆盖字段,不能原地改属性。
- Q:state 可以存函数吗? A:可以,此时更新函数会把传入函数当作更新器执行,需注意区分。
03.4.1.2-003 useReducer 适合什么场景?
一句话结论
useReducer 用 reducer 纯函数集中管理状态变更,适合状态结构复杂、多个子字段相互关联、更新逻辑需要集中测试或跨步骤流转的场景。
概念解释
- 状态通过 dispatch 触发 action,reducer 计算新状态。
- 与 useState 相比更新路径更显式,便于追踪变更。
- 简单单值状态用 useState 即可。
原理流程
- 定义 state 初始值与 reducer。
- 组件 dispatch action。
- reducer 返回新状态,组件重新渲染。
代码 / 示例
type State = { count: number };
type Action = { type: "inc" } | { type: "dec" };
function reducer(state: State, action: Action): State {
switch (action.type) {
case "inc": return { count: state.count + 1 };
case "dec": return { count: state.count - 1 };
}
}
const [state, dispatch] = useReducer(reducer, { count: 0 });
常见误区
- 误区:reducer 里可以直接改 state;正解:必须返回新状态对象,保持纯函数。
- 误区:useReducer 比 useState 性能更好;正解:差异主要在组织方式,不构成性能优劣结论。
追问
- Q:reducer 为什么要求纯函数? A:便于预测状态流转、测试与时间调试,副作用应放到 dispatch 前后处理。
- Q:useReducer 与外部状态库的 reducer 模式区别? A:前者状态局限于组件树,后者跨组件共享。
03.4.1.2-004 useRef 的两个用途是什么?
一句话结论
useRef 返回一个可变 .current 对象:一是保存 DOM 节点引用,二是在多次渲染间保留不触发重渲染的可变值(如计时器 id、上一次值)。
概念解释
- 修改 ref.current 不会触发组件渲染。
- ref 对象在组件生命周期内保持同一引用。
- 与 state 区别:state 变化触发渲染,ref 变化不触发。
原理流程
- 首次渲染创建 ref 对象。
- 赋值给 DOM 节点后 current 指向该节点。
- 普通可变值写入 current,读取时取最新值且不引起渲染。
代码 / 示例
const inputRef = useRef<HTMLInputElement>(null);
const timerRef = useRef<number | undefined>(undefined);
useEffect(() => {
timerRef.current = window.setTimeout(() => {}, 1000);
return () => clearTimeout(timerRef.current);
}, []);
常见误区
- 误区:在渲染过程中写 ref.current 作为派生状态;正解:渲染应保持纯净,ref 保存外部可变值或跨渲染实例。
- 误区:改 ref 会触发界面更新;正解:ref 变更不触发渲染,需要展示的值应放 state。
追问
- Q:如何保存“上一次渲染的值”? A:用 useEffect 或渲染后阶段把当前值写入 ref,下次渲染读取对比。
- Q:ref 回调函数与 ref 对象区别? A:字符串 ref 已废弃,回调 ref 在节点挂载/卸载时调用,对象 ref 直接挂到 current。
03.4.1.2-005 useMemo 缓存什么,什么时候该用?
一句话结论
useMemo 缓存计算结果,依赖不变时复用上次值;用于昂贵计算或需要稳定引用作为其他记忆化输入的对象/数组,不应无差别包裹所有计算。
概念解释
- 依赖数组变化才重新计算。
- 缓存值的引用保持稳定,避免子组件因新对象引用重复渲染。
- 自带缓存开销,简单计算包裹反而增加成本。
原理流程
- 首次执行计算函数得到结果。
- 依赖浅比较未变则返回缓存值。
- 依赖变化重新计算并覆盖缓存。
代码 / 示例
const sorted = useMemo(
() => [...list].sort((a, b) => a - b),
[list]
);
const config = useMemo(() => ({ size, theme }), [size, theme]);
常见误区
- 误区:useMemo 包裹所有变量防止重渲染;正解:缓存本身有成本,应按计算成本与引用稳定性收益选择。
- 误区:useMemo 缓存的是函数;正解:缓存计算结果,缓存回调函数用 useCallback。
追问
- Q:useMemo 返回对象引用稳定有什么用? A:作为 memo 子组件或其他 useMemo/useCallback 的依赖,避免因新引用失效。
- Q:依赖为空数组意味着什么? A:结果只在首次计算,后续永远复用首次值。
03.4.1.2-006 useCallback 缓存回调的原理与边界?
一句话结论
useCallback 返回依赖不变时引用稳定的回调函数,避免子组件因每次收到新函数引用而重复渲染;它本质是返回内联函数的 useMemo。
概念解释
- 依赖变化才创建新函数引用。
- 常配合
React.memo子组件使用。 - 回调内部用到的状态/ props 必须进入依赖数组。
原理流程
- 首次创建回调函数引用。
- 依赖浅比较未变复用旧引用。
- 依赖变化生成新函数并更新缓存。
代码 / 示例
const onSelect = useCallback((id: string) => {
setSelected(id);
}, []);
<MemoList onSelect={onSelect} />
常见误区
- 误区:useCallback 一定减少渲染;正解:子组件未做 memo 时,新引用与否都会重渲染,缓存没有收益。
- 误区:回调依赖可以省略;正解:遗漏依赖会让闭包读到过期值,应按规则补全。
追问
- Q:useCallback 与 useMemo 关系? A:
useCallback(fn, deps)等价于useMemo(() => fn, deps)。 - Q:函数需要稳定引用但内部逻辑频繁变怎么办? A:用 ref 保存最新回调,useCallback 包裹稳定转发,细节见 03.4.1.3。
03.4.1.2-007 Hooks 调用规则有哪些硬性要求?
一句话结论
只能在 React 函数组件或自定义 Hook 顶层调用,不能放在条件、循环、嵌套函数、回调或条件返回之后;调用顺序在每次渲染必须一致。
概念解释
- React 靠调用顺序匹配 Hook 状态,条件调用会打乱顺序。
- 规则适用于所有内置与自定义 Hook。
- 违反规则会导致状态错乱或报错。
原理流程
- 每次渲染按代码顺序执行 Hook。
- 内部按顺序从 Fiber Hook 链表取/存状态。
- 顺序不一致时状态与 Hook 错位。
代码 / 示例
// 错误:条件调用
if (count > 0) {
useEffect(() => {});
}
// 正确:条件逻辑放进 Hook 内部
useEffect(() => {
if (count > 0) { /* ... */ }
}, [count]);
常见误区
- 误区:Hook 可以写在事件回调里按需调用;正解:顶层规则不允许,回调内需要逻辑应写自定义 Hook 或在 useEffect 中处理。
- 误区:循环里调用 Hook 只要次数固定就行;正解:循环改变顺序与数量同样违规,应把列表项拆成独立组件。
追问
- Q:为什么 React 不靠 Hook 名字保存状态? A:早期设计按顺序链表存储,名称不参与匹配,因此要求顺序稳定。
- Q:违反规则的典型表现? A:Hook 状态错乱、渲染报错“Rendered more hooks than during the previous render”。
03.4.1.2-008 Hooks 内部如何按顺序保存状态?
一句话结论
每个 Fiber 上维护按调用顺序串联的 Hook 链表,节点保存状态值、依赖列表与队列;渲染时按顺序遍历匹配,更新节点内容而非重建结构。
概念解释
- 链表节点对应一次 Hook 调用。
- 状态、依赖、副作用队列挂在节点上。
- 顺序稳定是链表能正确匹配的前提。
原理流程
- 首次渲染依次创建 Hook 节点并连接。
- 后续渲染按相同顺序遍历节点。
- 读取/更新对应节点的状态与依赖。
代码 / 示例
Fiber Hooks 链表(概念):
Hook#1 useState(count)
Hook#2 useEffect(...)
Hook#3 useRef(timer)
每次渲染按 1→2→3 顺序访问
常见误区
- 误区:Hook 状态保存在组件函数闭包里;正解:状态挂在 Fiber 节点上,函数执行完闭包销毁,状态由 React 保留。
- 误区:可以根据条件跳过某个 Hook 调用而不影响后续;正解:跳过会让后续 Hook 全部错位。
追问
- Q:函数组件重新执行后状态为什么不丢? A:状态存在 Fiber 而非函数栈,渲染执行只是读取并返回当前值。
- Q:卸载组件时 Hook 状态去哪了? A:Fiber 子树销毁,对应 Hook 节点与副作用一并清理。
03.4.1.2-009 依赖数组如何比较,浅比较的局限是什么?
一句话结论
依赖数组按 Object.is 逐项浅比较;引用类型只要引用不变即视为未变,浅比较不深入对象内部;依赖变化才重新执行 memo/callback/effect。
概念解释
- 原始值比较值,对象/数组比较引用。
- 父级每次渲染新建的对象引用会让依赖失效。
- 遗漏依赖会导致闭包过期;多余依赖会造成不必要重跑。
原理流程
- 本次依赖数组与上次逐项 Object.is 比较。
- 全部相等复用缓存/跳过执行。
- 任一不等重新计算或执行副作用。
代码 / 示例
useEffect(() => {
document.title = `${count}`;
}, [count]); // count 原始值,按值比较
useMemo(() => build(options), [options]);
// options 每次新建对象引用会使缓存失效
常见误区
- 误区:深比较对象内容变化就会触发;正解:浅比较只看引用,内部字段变了引用不变不会触发。
- 误区:依赖数组可以省略写最快;正解:遗漏依赖是闭包过期的常见原因,应补全并配合 lint 规则检查。
追问
- Q:Object.is 与 === 差异? A:处理 NaN 与 -0 不同,其余基本一致。
- Q:对象依赖经常变化如何稳定引用? A:用 useMemo 固定对象,或把对象拆成原始值依赖分别传入。
03.4.1.2-010 什么是闭包陷阱,怎么解决?
一句话结论
闭包捕获的是渲染时刻的 state/props 快照,异步回调、定时器或事件里读到的可能是过期值;解决方式是函数式更新、补全依赖、用 ref 保存最新值或调整执行时机。
概念解释
- 每次渲染生成新闭包,捕获当次渲染的值。
- 旧闭包被异步任务保留时仍引用旧值。
- Hook 依赖数组决定闭包何时重建。
原理流程
- 渲染生成闭包,捕获本次 state。
- 异步任务延迟执行旧闭包。
- 旧闭包读到旧值;用更新器/ref/依赖刷新闭包修复。
代码 / 示例
// 过期闭包:定时器读到旧 count
useEffect(() => {
const id = setTimeout(() => console.log(count), 1000);
return () => clearTimeout(id);
}, []); // 遗漏 count 依赖
// 修复:补全依赖,或用函数式更新/ref
const countRef = useRef(count);
countRef.current = count;
常见误区
- 误区:setState 后回调里一定能读到新值;正解:异步回调捕获的是旧渲染闭包快照。
- 误区:把依赖留空就能避免重跑;正解:留空配合闭包外部值正是过期陷阱的典型来源。
追问
- Q:函数式更新为什么能绕过过期闭包? A:更新器接收队列中最新状态,不依赖闭包捕获的旧值。
- Q:ref 保存最新值适合什么场景? A:需要在稳定引用的回调里始终读取最新状态,又不希望回调因依赖变化重建。
03.4.1.2-011 自定义 Hook 如何抽取与复用逻辑?
一句话结论
把跨组件重复的状态与副作用逻辑封装成 use 开头的函数,内部调用内置 Hook,返回状态与操作方法;组件调用自定义 Hook 获得同一套能力,逻辑集中可测试。
概念解释
- 自定义 Hook 每次调用拥有独立状态。
- 可组合多个内置 Hook 完成完整逻辑。
- 返回值结构按业务约定设计。
原理流程
- 识别重复逻辑:状态、订阅、定时器、请求等。
- 封装为 useXxx,内部调用 Hook。
- 组件调用并解构返回值。
代码 / 示例
function useToggle(initial = false) {
const [on, setOn] = useState(initial);
const toggle = useCallback(() => setOn((v) => !v), []);
return [on, toggle] as const;
}
function Panel() {
const [open, toggle] = useToggle(false);
}
常见误区
- 误区:自定义 Hook 共享同一份状态;正解:每次调用独立实例,跨组件共享需 Context。
- 误区:Hook 里可以返回普通类实例替代状态;正解:实例可变且不触发渲染,交互状态仍应用 state/ref 组织。
追问
- Q:自定义 Hook 命名为什么以 use 开头? A:约定让工具与 lint 识别其 Hook 规则适用性。
- Q:Hook 内部如何暴露清理方法? A:在 useEffect 清理函数中处理,或返回手动清理函数供组件调用。
03.4.1.2-012 什么是状态提升?
一句话结论
当多个组件需要同一份状态时,把状态移到它们最近的共同父组件,通过 props 向下传值、回调向上通知,子组件保持受控。
概念解释
- 状态拥有者是父组件,子组件不各自维护副本。
- 避免两份状态不同步。
- 跨层级提升到共同祖先,或用 Context 避免逐层透传。
原理流程
- 识别需要共享状态的子组件。
- 在共同父组件建立 state 与更新回调。
- props 下发值与回调,子组件受控更新。
代码 / 示例
function Parent() {
const [term, setTerm] = useState("");
return (
<>
<SearchInput value={term} onChange={setTerm} />
<ResultList keyword={term} />
</>
);
}
常见误区
- 误区:每个子组件各自存一份相同状态再同步;正解:副本容易不一致,应提升到共同父级单一数据源。
- 误区:状态提升越深越好;正解:按共享范围提升到最近共同祖先,避免无关组件持有状态。
追问
- Q:层级很深不想逐层传 props 怎么办? A:用 Context 提供状态与更新方法,或引入状态管理库。
- Q:子组件需要本地 UI 状态时是否也要提升? A:只在本地使用的状态留在子组件,无需提升。
03.4.1.2-013 useState 的惰性初始化有什么用?
一句话结论
useState(initial) 直接传值时每次渲染都会计算该初始值;传入函数时只在首次渲染调用一次,适合昂贵初始值计算。
概念解释
- 普通初始值表达式在每次渲染都会执行。
- 惰性初始化把函数作为参数,仅首次调用。
- 首次之后忽略传入的初始化函数。
原理流程
- 首次渲染执行初始化得到状态。
- 后续渲染忽略初始参数。
- 昂贵计算(解析大对象、随机数、localStorage 读取)放初始化函数避免重复开销。
代码 / 示例
// 每次渲染都执行 parse
const [config, setConfig] = useState(parseLarge(raw));
// 仅首次执行
const [config, setConfig] = useState(() => parseLarge(raw));
常见误区
- 误区:传函数与传值初始化行为一样;正解:函数形式才是惰性初始化,普通表达式每次渲染求值。
- 误区:惰性初始化函数每次渲染都会调用;正解:只在挂载时调用一次。
追问
- Q:从 localStorage 读初始值注意什么? A:读取只在客户端执行,SSR 场景需避免访问浏览器 API。
- Q:更新函数形式的 setState 与惰性初始化混淆吗? A:前者是更新队列中的函数,后者是首次初始值函数,位置与用途不同。
03.4.1.2-014 多状态应该拆分还是合并?
一句话结论
互不关联的字段拆成多个 useState,更新时只变更对应字段;强相关、需要整体替换的状态可合并为一个对象;避免把所有字段塞进一个 state 后每次全量复制。
概念解释
- 拆分:更新局部字段不影响其他状态引用。
- 合并:相关字段作为整体流转,reducer 管理复杂结构。
- 对象 state 更新需复制旧对象覆盖变更字段。
原理流程
- 按字段关联度判断拆分或合并。
- 拆分状态各自独立更新。
- 合并状态用不可变更新覆盖目标字段。
代码 / 示例
// 拆分
const [name, setName] = useState("");
const [age, setAge] = useState(0);
// 合并(相关字段)
const [form, setForm] = useState({ name: "", age: 0 });
setForm((prev) => ({ ...prev, age: 1 }));
常见误区
- 误区:一个组件只能有一个 state;正解:可声明多个 useState,按字段组织。
- 误区:合并状态后每次更新都要复制全部字段;正解:展开旧对象后只覆盖变更字段。
追问
- Q:表单字段很多怎么组织? A:对象 state 或 useReducer 集中管理,按字段更新,避免大量独立 Hook。
- Q:拆分状态会导致多次渲染吗? A:同一事件中的多次更新会被批处理合并为一次提交,见 03.4.1.3。
03.4.1.2-015 状态更新如何进入队列并被批处理?
一句话结论
更新函数调用后把更新排入 Fiber 更新队列,React 在适当时机批量处理队列并触发重新渲染;同一事件循环内的多次更新会合并,具体批处理范围随 React 版本演进。
概念解释
- 更新不是同步改完立刻重渲染。
- 队列中更新按顺序计算最终状态。
- React 18 起自动批处理覆盖事件回调、Promise、定时器等场景,历史版本行为不同,版本边界待确认。
原理流程
- 调用 setState/dispatch 排入队列。
- 批量阶段按队列计算新状态。
- 提交阶段更新 DOM 与副作用。
代码 / 示例
function update() {
setCount((c) => c + 1);
setName("Ann"); // 同批处理,合并为一次提交
}
常见误区
- 误区:每次 setState 都立即刷新一次 DOM;正解:更新入队后批处理,减少重复渲染。
- 误区:所有版本批处理范围一致;正解:React 18 自动批处理扩大了覆盖范围,历史版本事件外更新行为不同。
追问
- Q:需要立刻同步拿到更新后 DOM 怎么办? A:
flushSync可强制同步提交,谨慎使用以免破坏批处理。 - Q:队列中多个函数式更新如何执行? A:按入队顺序依次基于前一个状态计算。
03.4.1.2-016 派生状态为什么通常不用 state 保存?
一句话结论
能由现有 state/props 直接计算得出的值属于派生数据,应在渲染时计算或用 useMemo 缓存,而不是另存一份 state 再手动同步,避免双数据源不一致。
概念解释
- 派生值可由输入推导,保存为 state 容易遗漏同步时机。
- 渲染时计算最简单;昂贵计算用 useMemo。
- 只有“交互产生、无法从输入推导”的值才需要 state。
原理流程
- 判断值是否可由现有状态推导。
- 可推导:渲染计算或 memo 缓存。
- 不可推导:建立 state 并在交互时更新。
代码 / 示例
const items = useItemList();
// 派生:渲染时计算,不另存 state
const total = items.reduce((sum, it) => sum + it.price, 0);
const visible = items.filter((it) => it.active);
常见误区
- 误区:把过滤/排序结果存成 state,监听原列表再更新;正解:直接派生计算,省去同步逻辑。
- 误区:派生值必须用 useMemo;正解:简单计算直接渲染时计算即可。
追问
- Q:派生值依赖异步数据怎么办? A:数据加载后在渲染中计算,加载中给出空/占位结果。
- Q:什么值必须用 state? A:用户输入、开关状态、选择项等交互产生、无法由 props 推导的值。
03.4.1.2-017 受控表单状态如何组织?
一句话结论
表单字段值由 state 持有,输入事件更新 state,校验与派生信息从 state 计算;多字段可用对象 state 或 reducer 集中管理,提交时读取状态。
概念解释
- 每个输入绑定 value 与 onChange。
- 校验规则从当前值派生,不在 onChange 里复制一份错误状态。
- 提交动作调用 state 读取最新值。
原理流程
- 建立表单初始状态。
- 输入更新对应字段。
- 渲染时计算校验提示,提交时读取状态。
代码 / 示例
const [form, setForm] = useState({ name: "", email: "" });
const onChange = (key: keyof typeof form) =>
(e: React.ChangeEvent<HTMLInputElement>) =>
setForm((prev) => ({ ...prev, [key]: e.target.value }));
const valid = form.name.trim() !== "" && /@/.test(form.email);
常见误区
- 误区:错误提示在 onChange 里手动写入另一份 state;正解:错误由当前值派生计算。
- 误区:非受控表单也要全量 state;正解:简单表单可用非受控,提交时经 ref 读取。
追问
- Q:字段很多如何减少重复样板? A:封装字段组件或用 reducer 统一处理变更动作。
- Q:异步提交中的加载状态放哪? A:独立 state 标记 pending/error,与表单字段状态分开。
03.4.1.2-018 Hooks 相比类实例状态有哪些复用优势?
一句话结论
Hooks 把逻辑按功能聚合为可组合的自定义 Hook,避免类组件中生命周期分散、高阶组件嵌套与 this 绑定问题;同一 Hook 逻辑可在多个组件复用,类型推断更直接。
概念解释
- 类组件同一功能的逻辑分散在多个生命周期方法中。
- 复用过去依赖 HOC、渲染属性,形成嵌套层级。
- Hook 按功能聚合状态、副作用与操作方法。
原理流程
- 识别可复用功能边界。
- 封装自定义 Hook 组合内置 Hook。
- 多组件调用复用同一逻辑,无组件层级嵌套。
代码 / 示例
// 复用:订阅窗口尺寸
function useWindowSize() {
const [size, setSize] = useState({ w: 0, h: 0 });
useEffect(() => {
const onResize = () => setSize({ w: innerWidth, h: innerHeight });
onResize();
window.addEventListener("resize", onResize);
return () => window.removeEventListener("resize", onResize);
}, []);
return size;
}
常见误区
- 误区:自定义 Hook 等价于高阶组件;正解:Hook 返回状态与方法,不包裹组件树,无层级嵌套。
- 误区:Hook 复用会共享状态;正解:独立调用实例状态隔离,共享需 Context。
追问
- Q:类组件 this 绑定在 Hook 中还存在吗? A:函数组件没有 this 实例,回调通过闭包与依赖引用值,减少绑定问题。
- Q:复杂复用逻辑如何分层? A:底层通用 Hook(尺寸、事件、请求)→ 业务 Hook(页面数据组合)→ 组件调用。