显示页面讨论过去修订反向链接回到顶部 本页面只读。您可以查看源文件,但不能更改它。如果您觉得这是系统错误,请联系管理员。 ====== 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 - 有引用比较需求才用 - 滥用不如不用 ``` 登录 Detach Close 该主题尚不存在 您访问的页面并不存在。如果允许,您可以使用创建该页面按钮来创建它。 react/usecallback.txt 最后更改: 2026/10/16 09:40由 张叶安 登录