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 直接算出来的,就别写进依赖;能放进函数内部定义的常量,也不会成为依赖。

这是 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} />
    </>
  );
}

稳定的函数引用能避免 effect 被无谓地反复执行:

const fetchData = useCallback(async () => {
  const res = await fetch(`/api/posts/${id}`);
  setData(await res.json());
}, [id]);
 
useEffect(() => {
  fetchData();
}, [fetchData]);   // fetchData 稳定 → id 不变时 effect 不会重跑

自定义 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 };
}
const handleKeyDown = useCallback(e => {
  if (e.key === 'Escape') close();
}, [close]);
 
useEffect(() => {
  window.addEventListener('keydown', handleKeyDown);
  return () => window.removeEventListener('keydown', handleKeyDown);
}, [handleKeyDown]);

useCallback 本质上就是 useMemo 的一个特例:

// 下面两种写法完全等价
const fn = useCallback(() => doSomething(a), [a]);
const fn = useMemo(() => () => doSomething(a), [a]);
Hook 缓存的东西 典型用法
useMemo 计算结果 昂贵计算、稳定的对象/数组
useCallback 函数本身 传给 memo 子组件的回调、effect 依赖

简单记:useMemo 缓存值,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 后子组件仍然重渲染 常见原因有三个:子组件没用 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'' 缓存函数。

  • 没有引用比较需求就不要用,滥用只会增加负担。
# 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.txt
  • 最后更改: 2026/10/16 09:40
  • 由 张叶安