useCallback
useCallback 是 React 提供的一个 Hook(钩子),用来在多次渲染之间复用同一个函数引用。
一句话概括:useCallback 让你的函数「第一次渲染时创建,之后一直用同一个」,只要依赖项没变,返回的就是同一个函数对象。
注意:它不是用来让函数跑得更快的。函数本身的执行速度不会因为 useCallback 有任何变化,它真正的作用是保持函数引用的稳定,从而让依赖这个引用的 React.memo、useEffect、useMemo 不会白白重新执行。
为什么需要它
React 函数组件每次渲染都会重新执行整个函数体,因此组件里写的每个函数每次渲染都是全新的对象:
function Parent() { const [count, setCount] = useState(0); // 每次 Parent 渲染,这个函数都是新创建的 const handleClick = () => { console.log('clicked'); } return <Child onClick={handleClick} />; }
问题的关键在于 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 <button onClick={onAdd}>+1</button>; }); function Parent() { const [count, setCount] = useState(0); const [text, setText] = useState(''); // 依赖为 [],handleAdd 永远是同一个引用 const handleAdd = useCallback(() => { setCount(prev => prev + 1); }, []); return ( <div> <input value={text} onChange={e => setText(e.target.value)} /> <Child onAdd={handleAdd} /> </div> ); }
在输入框里打字时,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 => ( <button key={item.id} onClick={() => onSelect(item.id)}> {item.name} </button> )); }); function App() { const [items, setItems] = useState([]); const [keyword, setKeyword] = useState(''); // 不用 useCallback:App 每次渲染 List 都会重渲染 const handleSelect = useCallback(id => { console.log('selected', id); }, []); return ( <> <input value={keyword} onChange={e => setKeyword(e.target.value)} /> <List items={items} onSelect={handleSelect} /> </> ); }
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. 依赖里放了每次新建的对象
<code javascript>
options 每次渲染都是新对象 → 缓存一直失效
const send = useCallback(() ⇒ { … }, [options]);
改成依赖具体字段
const send = useCallback(() ⇒ { … }, [options.size, options.type]);
</code>
3. 到处乱包
每个组件里的每个函数都套一层 useCallback,代码噪音大、性能也不见得更好。只在确实有引用比较需求的地方使用。
4. 加上 useCallback 后子组件仍然重渲染
常见原因有三个:子组件没用 onClick={() ⇒ fn()}React.memo;传给子组件的其他 prop(对象/数组)每次都新建;在 JSX 里写成了 ,内联箭头函数把缓存又破坏了。
<code javascript>
缓存白费:内联箭头函数每次都是新引用
<List onSelect={id ⇒ handleSelect(id)} />
正确:直接把稳定函数传下去
<List onSelect={handleSelect} />
</code>
5. 在条件或循环中调用
和所有 Hook 一样,必须在顶层调用,否则破坏 Hook 顺序、报错。
6. 想靠它提升计算性能
useCallback 不会让函数执行得更快,只是避免重复创建引用。真正昂贵的计算要用 useMemo。
===== 小结 =====
* useCallback(fn, deps) 在依赖不变时返回同一个函数引用。
* 它解决的是引用稳定性,不是函数执行速度。
* 场景:useEffectReact.memo 子组件的回调、effect / memo 的依赖、自定义 Hook 返回的函数。
* 依赖数组与 规则一致(Object.is 浅比较),漏写依赖会读到旧值。
* 用 setState 的函数式更新可以显著减少依赖。
* 它等价于 useMemo(() ⇒ fn, deps):useMemo 缓存值,useCallback'' 缓存函数。
- 没有引用比较需求就不要用,滥用只会增加负担。
相关页面
- usestate —— 状态与重新渲染
- useeffect —— effect 依赖稳定引用的必要性
- props-state —— Props 与 State、组件间传递回调
- 组件基础 —— 组件、传参与数据流
- 事件处理 —— 事件回调与事件对象
- 基础概念 —— React 核心思想
# 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
- 有引用比较需求才用
- 滥用不如不用