function Parent() {
const [count, setCount] = useState(0);
// 每次 Parent 渲染,这个函数都是新创建的
const handleClick = () => {
console.log('clicked');
}
return ;
}
问题的关键在于 **JS 里函数是引用类型**:''handleClick'' 每次都是新的引用,虽然逻辑一模一样。
| 引用变化带来的后果 | 说明 |
| 传给 ''React.memo'' 子组件 | 浅比较发现 props 变了,子组件被迫重新渲染 |
| 作为 ''useEffect'' 的依赖 | effect 每次渲染都重新执行 |
| 作为 ''useMemo'' 的依赖 | 缓存失效,白白重算 |
''useCallback'' 就是解决「引用每次都不一样」这个问题的。
===== 基本语法 =====
const memoizedFn = useCallback(() => {
// 函数体
}, [依赖项]);
* **第一个参数**:你要缓存的函数
* **第二个参数**:**依赖数组**,数组里任一项变化时才会创建新的函数;传 ''[]'' 表示永远返回第一次创建的那个
* **返回值**:当前这次渲染应该使用的函数
和 ''useState''、''useEffect'' 一样,''useCallback'' 必须写在组件或自定义 Hook 的**最顶层**,不能放在条件、循环里。
===== 一句话理解 =====
import { useState, useCallback, memo } from 'react';
const Child = memo(function Child({ onAdd }) {
console.log('Child 渲染了');
return ;
});
function Parent() {
const [count, setCount] = useState(0);
const [text, setText] = useState('');
// 依赖为 [],handleAdd 永远是同一个引用
const handleAdd = useCallback(() => {
setCount(prev => prev + 1);
}, []);
return (
setText(e.target.value)} />
);
}
在输入框里打字时,''Parent'' 会重新渲染,但 ''handleAdd'' 的引用没变,''Child'' 通过 ''memo'' 的浅比较后**不会重新渲染**。若去掉 ''useCallback'',每次打字 ''Child'' 都会跟着渲染。
===== 依赖数组 =====
| 写法 | 行为 | 适用场景 |
| ''[]'' | 永远复用第一次创建的函数 | 函数内不读取任何会变的响应式值 |
| ''[a, b]'' | a 或 b 变化时创建新函数 | 函数内用到了 a、b |
| 不传 | 等于没有缓存,每次都是新函数 | 没有意义,别这么写 |
// 函数里用到了 id,就必须把 id 放进依赖
const load = useCallback(() => {
fetch(`/api/user/${id}`); // 用到了 id
}, [id]); // 漏写 id → 永远用第一次的旧 id
// 用到了父组件传来的 onSave,也要写进依赖
const handleSave = useCallback(() => {
onSave(formData);
}, [onSave, formData]);
**依赖数组里的值和 ''useEffect'' 一样是 ''Object.is'' 浅比较**。如果依赖本身是每次新建的对象或函数,''useCallback'' 就完全失效了,这时要么把依赖也稳定下来,要么让依赖尽量是原始值(如 ''id''、''page'',而不是整个 ''filters'' 对象)。
===== 用函数式更新减少依赖 =====
这是让 ''useCallback'' 依赖尽量少、最常用的技巧:**用 ''setState'' 的函数式写法,就不必依赖那个 state**。
// 依赖里有 count:count 一变,函数就要重建
const handleAdd = useCallback(() => {
setCount(count + 1);
}, [count]);
// 用 prev 取值:依赖为空,函数永远稳定
const handleAdd = useCallback(() => {
setCount(prev => prev + 1);
}, []);
同理,能从 ''props'' 直接算出来的,就别写进依赖;能放进函数内部定义的常量,也不会成为依赖。
===== 常见使用场景 =====
==== 1. 配合 React.memo 的子组件 ====
这是 ''useCallback'' **最主要、也几乎是唯一必要**的场景:
const List = memo(function List({ items, onSelect }) {
return items.map(item => (
));
});
function App() {
const [items, setItems] = useState([]);
const [keyword, setKeyword] = useState('');
// 不用 useCallback:App 每次渲染 List 都会重渲染
const handleSelect = useCallback(id => {
console.log('selected', id);
}, []);
return (
<>
setKeyword(e.target.value)} />
>
);
}
==== 2. 作为 useEffect / useMemo 的依赖 ====
稳定的函数引用能避免 effect 被无谓地反复执行:
const fetchData = useCallback(async () => {
const res = await fetch(`/api/posts/${id}`);
setData(await res.json());
}, [id]);
useEffect(() => {
fetchData();
}, [fetchData]); // fetchData 稳定 → id 不变时 effect 不会重跑
==== 3. 自定义 Hook 返回函数 ====
自定义 Hook 返回的函数常被调用方放进依赖,稳定引用能避免调用方的 effect 无限循环:
function useToggle(initial = false) {
const [on, setOn] = useState(initial);
const toggle = useCallback(() => setOn(v => !v), []);
const setTrue = useCallback(() => setOn(true), []);
return { on, toggle, setTrue };
}
==== 4. 需要稳定引用的订阅 / 事件注册 ====
const handleKeyDown = useCallback(e => {
if (e.key === 'Escape') close();
}, [close]);
useEffect(() => {
window.addEventListener('keydown', handleKeyDown);
return () => window.removeEventListener('keydown', handleKeyDown);
}, [handleKeyDown]);
===== 和 useMemo 的关系 =====
''useCallback'' 本质上就是 ''useMemo'' 的一个特例:
// 下面两种写法完全等价
const fn = useCallback(() => doSomething(a), [a]);
const fn = useMemo(() => () => doSomething(a), [a]);
| Hook | 缓存的东西 | 典型用法 |
| ''useMemo'' | **计算结果** | 昂贵计算、稳定的对象/数组 |
| ''useCallback'' | **函数本身** | 传给 memo 子组件的回调、effect 依赖 |
简单记:''useMemo'' 缓存**值**,''useCallback'' 缓存**函数**。
===== 什么时候不需要 useCallback =====
**这是最重要的一节。** 滥用 ''useCallback'' 的代价是:每次渲染都要比较依赖、要分配内存保存缓存,反而更慢,代码也更啰嗦。
遇到下面的情况**不需要**用它:
| 情况 | 说明 |
| 函数只在本组件内用,不传给 ''memo'' 子组件 | 引用是否变化无人关心 |
| 子组件没有用 ''React.memo'' 包裹 | 父组件渲染时子组件本来就会渲染 |
| 函数不放进任何依赖数组 | 没人比较它的引用 |
| 依赖项本身每次都变 | 缓存必然失效,等于白写 |
| 只是想在事件里调用的箭头函数 | 写在 JSX 里最直观 |
判断标准可以简化成一句话:**「这个函数的引用,会不会被别人拿去比较?」** 会,就用 ''useCallback'';不会,就别加。
另外,React 19 / React Compiler 能自动完成这类记忆化,新项目里这类手动优化的重要性正在下降;但理解它仍然是读懂现有代码的前提。
===== 常见坑 =====
**1. 以为 ''useCallback'' 冻结了闭包里的值**
函数内部的变量**仍然是当次渲染的快照**。依赖数组没写全,读到的就是旧值:
const [count, setCount] = useState(0);
const log = useCallback(() => {
console.log(count); // 用到了 count
}, []); // 但依赖为空
// 点三次 +1 后调用 log(),打印的仍然是 0
正确做法是补上依赖 ''[count]'',或用函数式更新''/''useRef'' 绕过。
**2. 依赖里放了每次新建的对象**
// options 每次渲染都是新对象 → 缓存一直失效
const send = useCallback(() => { ... }, [options]);
// 改成依赖具体字段
const send = useCallback(() => { ... }, [options.size, options.type]);
**3. 到处乱包**
每个组件里的每个函数都套一层 ''useCallback'',代码噪音大、性能也不见得更好。只在**确实有引用比较需求**的地方使用。
**4. 加上 useCallback 后子组件仍然重渲染**
常见原因有三个:子组件**没用 ''React.memo''**;传给子组件的**其他 prop(对象/数组)每次都新建**;在 JSX 里写成了 ''onClick={() => fn()}'',**内联箭头函数把缓存又破坏了**。
// 缓存白费:内联箭头函数每次都是新引用
handleSelect(id)} />
// 正确:直接把稳定函数传下去
**5. 在条件或循环中调用**
和所有 Hook 一样,必须在顶层调用,否则破坏 Hook 顺序、报错。
**6. 想靠它提升计算性能**
''useCallback'' 不会让函数执行得更快,只是避免**重复创建引用**。真正昂贵的计算要用 ''useMemo''。
===== 小结 =====
* ''useCallback(fn, deps)'' 在依赖不变时**返回同一个函数引用**。
* 它解决的是**引用稳定性**,不是函数执行速度。
* 场景:**''React.memo'' 子组件的回调、effect / memo 的依赖、自定义 Hook 返回的函数**。
* 依赖数组与 ''useEffect'' 规则一致(''Object.is'' 浅比较),**漏写依赖会读到旧值**。
* 用 ''setState'' 的**函数式更新**可以显著减少依赖。
* 它等价于 ''useMemo(() => fn, deps)'':''useMemo'' 缓存值,''useCallback'' 缓存函数。
* **没有引用比较需求就不要用**,滥用只会增加负担。
===== 相关页面 =====
* [[react:usestate]] —— 状态与重新渲染
* [[react:useeffect]] —— effect 依赖稳定引用的必要性
* [[react:props-state]] —— Props 与 State、组件间传递回调
* [[react:组件基础]] —— 组件、传参与数据流
* [[react:事件处理]] —— 事件回调与事件对象
* [[react:基础概念]] —— React 核心思想
```mdk height=480 color=#4f46e5
# useCallback
## 是什么
- React 内置 Hook
- 多次渲染间复用同一个函数引用
- 不是让函数跑得更快
- 解决的是「引用稳定性」
- 必须写在组件顶层
## 为什么需要
- 组件每次渲染都重建函数
- 函数是引用类型,每次都是新对象
- 传给 React.memo 子组件 → 被迫重渲染
- 作为 useEffect 依赖 → effect 反复执行
- 作为 useMemo 依赖 → 缓存失效
## 基本语法
- `const fn = useCallback(() => {}, [deps])`
- 依赖不变 → 返回同一个函数
- 依赖变化 → 创建新函数
- `[]` → 永远复用第一个
## 依赖数组
- Object.is 浅比较
- 漏写依赖 → 闭包读到旧值
- 依赖里放新建对象 → 缓存失效
- 优先依赖原始值
- 用 setState 函数式更新减少依赖
## 常见场景
- 配合 React.memo 的子组件(主要场景)
- 作为 useEffect / useMemo 的依赖
- 自定义 Hook 返回的函数
- 事件订阅的稳定回调
## 与 useMemo 的关系
- `useCallback(fn, deps)` ≡ `useMemo(() => fn, deps)`
- useMemo 缓存「值」
- useCallback 缓存「函数」
## 什么时候不用
- 没传给 memo 子组件
- 子组件没包 React.memo
- 函数不进任何依赖数组
- 依赖本身每次都变
- 判断标准:引用会不会被别人比较
## 常见坑
- 以为它冻结了闭包里的值
- 依赖里放了每次新建的对象
- 到处乱包,反而更慢
- 子组件没加 memo
- JSX 内联箭头函数破坏缓存
- 在条件 / 循环里调用
- 靠它提升计算性能(该用 useMemo)
## 小结
- 保持函数引用稳定
- 依赖规则同 useEffect
- 有引用比较需求才用
- 滥用不如不用
```