useMemo

useMemo 是 React 提供的一个 Hook(钩子),用来在多次渲染之间缓存一次计算的结果。依赖项没变时直接复用上次的值,不再重新计算。

一句话概括:「依赖没变,就别再算了,把上次的结果给我。」

要注意它不是让计算变快的开关,而是避免重复执行本可以不执行的计算。真正的收益来自「少算」,而不是「算得快」。

import { useMemo, useState } from 'react';
 
function ProductList({ products }) {
  const [keyword, setKeyword] = useState('');
 
  // products 或 keyword 不变时,这段过滤不会重新执行
  const filtered = useMemo(() => {
    console.log('执行过滤');
    return products.filter(p => p.name.includes(keyword));
  }, [products, keyword]);
 
  return (
    <div>
      <input value={keyword} onChange={e => setKeyword(e.target.value)} />
      <ul>
        {filtered.map(p => <li key={p.id}>{p.name}</li>)}
      </ul>
    </div>
  );
}

组件因为别的原因重新渲染时(比如父组件刷新、某个无关的 state 变化),只要 products 和 keyword 没变,useMemo 就直接返回上次的结果,跳过整个 filter。

const value = useMemo(createFn, deps);
  • 第一个参数:计算函数,必须 return 一个值
  • 第二个参数:依赖数组,里面任一项变化时才重新执行计算函数
  • 返回值:缓存下来的计算结果
const total = useMemo(() => items.length, [items]);
const sorted = useMemo(() => [...list].sort((a, b) => a - b), [list]);
const options = useMemo(() => ({ page, size }), [page, size]);

和所有 Hook 一样,useMemo 必须写在组件或自定义 Hook 的最顶层,不能放在条件、循环、嵌套函数里。

写法 行为 适用场景
[] 只计算一次,之后一直复用 计算不依赖任何会变的值
[a, b] a 或 b 变化时重新计算 计算用到了 a、b
不传 每次渲染都重新计算,等于没缓存 没有意义,别这么写

依赖是 Object.is 浅比较,和 useEffect 规则完全一致:用到了什么就必须写什么,写漏会拿到旧值,多写会让缓存失效。

最典型也最正当的场景。filter、sort、正则匹配、复杂映射在大数据量下开销明显:

function UserTable({ users, keyword, sortBy }) {
  const [selected, setSelected] = useState(null);   // 与列表计算无关的状态
 
  const rows = useMemo(() => {
    const filtered = users.filter(u => u.name.includes(keyword));
    return [...filtered].sort((a, b) => a[sortBy] - b[sortBy]);
  }, [users, keyword, sortBy]);
 
  // 选中某一行会触发渲染,但 rows 不会重新计算
  return (
    <table>
      <tbody>
        {rows.map(u => (
          <tr key={u.id} onClick={() => setSelected(u.id)}>
            <td>{u.name}</td>
          </tr>
        ))}
      </tbody>
    </table>
  );
}

注意这里的关键点:selected 变化时组件会重渲染,但它不在依赖里,所以过滤排序被完全跳过——这正是收益所在。

由现有状态推导出来的数据,用 useMemo 包一层,避免每次渲染都遍历一遍:

function Cart({ items }) {
  const total = useMemo(
    () => items.reduce((sum, item) => sum + item.price * item.qty, 0),
    [items]
  );
 
  const count = useMemo(
    () => items.reduce((sum, item) => sum + item.qty, 0),
    [items]
  );
 
  return (
    <div>
      共 {count} 件,合计 ¥{total.toFixed(2)}
    </div>
  );
}

这类数据绝不能放进 useState,它就是「由 state 算出来的」,算就是了(参考 props-state)。

这是比性能优化更重要的用途。每次渲染都新建的对象,会让依赖它的 useEffect 每次渲染都重新执行:

// 问题:options 每次渲染都是新对象 → effect 每次渲染都重跑
function List({ page, size }) {
  const options = { page, size };          // 新引用!
 
  useEffect(() => {
    fetchList(options);
  }, [options]);                           // 永远在变 → 反复请求,甚至死循环
}
 
// 解决:用 useMemo 把引用固定住
function List({ page, size }) {
  const options = useMemo(() => ({ page, size }), [page, size]);
 
  useEffect(() => {
    fetchList(options);
  }, [options]);                           // page / size 不变,effect 就不重跑
}

同样的道理适用于把对象、数组作为 useMemo / useCallback 的依赖,或作为 useCallback 内部读取的值。

React.memo 做的是浅比较。传下去的 prop 如果是每次渲染新建的对象或数组,memo 就完全失效:

const Chart = memo(function Chart({ data, style }) {
  console.log('Chart 渲染了');
  return <div style={style}>{JSON.stringify(data)}</div>;
});
 
function Dashboard({ raw }) {
  const [tab, setTab] = useState('a');
 
  // 不加 useMemo:Dashboard 每次渲染 Chart 都会重渲染
  const data = useMemo(() => raw.map(r => r.value), [raw]);
  const style = useMemo(() => ({ width: '100%', height: 240 }), []);
 
  return (
    <>
      <button onClick={() => setTab(tab === 'a' ? 'b' : 'a')}>切换</button>
      <Chart data={data} style={style} />
    </>
  );
}

切换 tab 时 data、style 引用不变,Chart 就会被 memo 拦下来,不重新渲染。

依赖越“细”,缓存命中率越高。做法是把依赖拆到原始值上:

// 依赖整个 filter 对象:只要对象换了引用就重算
const result = useMemo(() => search(list, filter), [list, filter]);
 
// 依赖具体字段:其他字段变化不会导致重算
const result = useMemo(
  () => search(list, { keyword: filter.keyword, type: filter.type }),
  [list, filter.keyword, filter.type]
);

自定义 Hook 返回的对象如果每次都是新的,调用方只要把它放进依赖就会反复触发:

function usePagination(total, pageSize) {
  const [page, setPage] = useState(1);
 
  const totalPages = useMemo(() => Math.ceil(total / pageSize), [total, pageSize]);
 
  // 返回稳定对象,调用方可以安全地放进 effect 依赖
  return useMemo(
    () => ({ page, totalPages, next: () => setPage(p => p + 1) }),
    [page, totalPages]
  );
}

严格来说 next 这里每次也会重建,若要彻底稳定,再配一个 useCallback(见 usecallback)。

useCallback 就是 useMemo 特例,缓存函数时两者可以互换:

// 完全等价
const handleClick = useCallback(() => doSomething(a), [a]);
const handleClick = useMemo(() => () => doSomething(a), [a]);

实际写代码时:缓存函数用 useCallback,缓存值用 useMemo,语义更清楚。

这一节和示例同样重要。 滥用 useMemo 的代价是:每次渲染都要比较依赖、都要占用内存保存缓存,代码还更啰嗦。对廉价计算用它,反而可能更慢。

情况 说明
计算很简单 a + b、items.length、拼几个字符串,直接算更快
结果没有任何人在意引用 只渲染成文本,不进依赖、不传给 memo 组件
依赖本身每次都变 缓存必然失效,写了等于白写
子组件没包 React.memo 父组件渲染时子组件照样渲染
只是在 JSX 里写个小表达式 内联写最直观

判断标准简化成一句话:「这个计算贵不贵?算出来的引用有没有被别人比较?」 两个都是“是”,就值得用;否则不要加。

补充:React 19 / React Compiler 能自动完成大部分记忆化,新项目里手动 useMemo 的需要在减少;但读懂现有代码里为什么这么写,仍然是必备技能。

1. 以为加了 useMemo,子组件就不会重渲染

useMemo 只保证自己这次返回的是同一个引用。子组件要真的跳过渲染,必须:

  • 子组件用 React.memo 包裹
  • 所有 prop 都稳定(有个 prop 每次新建,整层缓存就白费)
// 白费:onSelect 每次都是新函数,memo 比较失败
<List data={data} onSelect={id => select(id)} />
 
// 正确:函数也用 useCallback 固定
<List data={data} onSelect={handleSelect} />

2. 依赖写漏 → 拿到旧值

useMemo 缓存的是当时的闭包快照,依赖没写全,读到的就是旧数据:

const [keyword, setKeyword] = useState('');
 
// 用到了 keyword,却忘了写进依赖 → 永远是第一次的过滤结果
const filtered = useMemo(() => list.filter(i => i.name.includes(keyword)), [list]);

用 ESLint 的 react-hooks/exhaustive-deps 规则可以自动检查。

3. 依赖里放了每次新建的对象

const style = { color: 'red' };                 // 每次渲染都是新对象
const node = useMemo(() => <Box style={style} />, [style]);  // 缓存永远失效
 
const style = useMemo(() => ({ color: 'red' }), []);         // 先把它固定住

4. 用 useMemo 放副作用

计算函数应该是纯函数。发请求、改 DOM、写 localStorage 这类事属于 useEffect 或事件处理,不要塞进 useMemo。

5. 在条件或循环里调用

和所有 Hook 一样必须在顶层,否则破坏 Hook 顺序,报错 “Rendered fewer hooks than expected”。

6. 缓存的东西根本不该是 state

如果某个值完全由已有数据算出来,就别再存一份 state,否则要同步两份数据——直接用 useMemo 派生。

Hook 缓存的东西 典型用途
useMemo 计算结果(值) 昂贵计算、派生数据、稳定对象/数组
useCallback 函数本身 传给 memo 子组件的回调、effect 依赖
React.memo 组件渲染结果 跳过 props 未变的子组件渲染
useEffect 不缓存 与外部系统同步(请求、订阅、DOM)
useRef 可变容器 不触发渲染的值、DOM 引用
  • useMemo(fn, deps) 在依赖不变时复用上次的计算结果,不再执行 fn。
  • 它缓存的是值;useCallback 缓存的是函数,两者是特例关系。
  • 两大用途:省掉昂贵计算、固定对象 / 数组引用(让 useEffect、memo 不白跑)。
  • 依赖用 Object.is 浅比较,写漏会拿旧值,多写会失效;优先依赖原始值。
  • 计算函数必须是纯函数,副作用交给 useEffect。
  • 计算廉价、引用没人比较时就别用,滥用反而是负担。
# useMemo

## 是什么
- React 内置 Hook
- 多次渲染间缓存一次计算结果
- 依赖不变 → 直接复用上次的值
- 不是让计算变快
- 收益来自「少算」
- 必须写在组件顶层

## 基本语法
- `const v = useMemo(createFn, deps)`
- 计算函数必须 return 值
- 依赖变化才重新执行
- 返回缓存的结果
- 不能在 if / for 里调用

## 依赖数组
- `[]` → 只算一次
- `[a, b]` → a 或 b 变化时重算
- 不传 → 等于没缓存
- Object.is 浅比较
- 写漏 → 拿到旧值
- 依赖越细,命中率越高

## 具体用法示例
### 昂贵计算
- 大列表 filter + sort
- 正则匹配、复杂 map
- 无关 state 变化时跳过计算
### 派生数据
- 购物车总价 / 件数
- 由 state 推导,不进 state
### 稳定引用
- 固定对象,避免 effect 反复执行
- 防止依赖对象导致的死循环
### 传给 memo 子组件
- React.memo 是浅比较
- 对象 / 数组 prop 必须稳定
- 配 useCallback 固定回调
### 自定义 Hook
- 返回稳定的对象
- 调用方可安全放进依赖

## 与 useCallback
- `useCallback(fn, d)` ≡ `useMemo(() => fn, d)`
- useMemo 缓存「值」
- useCallback 缓存「函数」
- 缓存函数用 useCallback 更清晰

## 什么时候不用
- 计算很简单(加减、length)
- 结果引用没人比较
- 依赖本身每次都变
- 子组件没包 React.memo
- JSX 内联小表达式
- 判断:贵不贵 + 引用是否被比较

## 常见坑
- 以为能阻止子组件重渲染
- 漏写依赖拿到旧快照
- 依赖里放每次新建的对象
- 用 useMemo 写副作用
- 在条件 / 循环里调用
- 缓存廉价计算反而更慢

## 小结
- 缓存值,不缓存执行速度
- 省计算 + 稳引用
- 依赖规则同 useEffect
- 没有收益就不要加

该主题尚不存在

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

  • react/usememo.txt
  • 最后更改: 2026/11/09 14:28
  • 由 张叶安