差别

这里会显示出您选择的修订版和当前版本之间的差别。

到此差别页面的链接

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

该主题尚不存在

您访问的页面并不存在。如果允许,您可以使用创建该页面按钮来创建它。

  • react/usecallback.1792114737.txt.gz
  • 最后更改: 2026/10/16 09:38
  • 由 张叶安