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 (
setKeyword(e.target.value)} />
{filtered.map(p => - {p.name}
)}
);
}
组件因为别的原因重新渲染时(比如父组件刷新、某个无关的 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'' 规则完全一致:用到了什么就必须写什么,写漏会拿到旧值,多写会让缓存失效。
===== 具体用法示例 =====
==== 1. 缓存昂贵计算:过滤 + 排序大列表 ====
最典型也最正当的场景。''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 (
{rows.map(u => (
setSelected(u.id)}>
{u.name}
))}
);
}
注意这里的关键点:''selected'' 变化时组件会重渲染,但它**不在依赖里**,所以过滤排序被完全跳过——这正是收益所在。
==== 2. 派生数据:购物车总价 ====
由现有状态推导出来的数据,用 ''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 (
共 {count} 件,合计 ¥{total.toFixed(2)}
);
}
这类数据**绝不能放进 ''useState''**,它就是「由 state 算出来的」,算就是了(参考 [[react:props-state]])。
==== 3. 保持对象 / 数组引用稳定:作为其他 Hook 的依赖 ====
这是**比性能优化更重要的用途**。每次渲染都新建的对象,会让依赖它的 ''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'' 内部读取的值。
==== 4. 传给 React.memo 子组件的对象 prop ====
''React.memo'' 做的是**浅比较**。传下去的 prop 如果是每次渲染新建的对象或数组,''memo'' 就完全失效:
const Chart = memo(function Chart({ data, style }) {
console.log('Chart 渲染了');
return {JSON.stringify(data)};
});
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 (
<>
>
);
}
切换 ''tab'' 时 ''data''、''style'' 引用不变,''Chart'' 就会被 ''memo'' 拦下来,不重新渲染。
==== 5. 依赖对象的具体字段,而不是整个对象 ====
依赖越"细",缓存命中率越高。做法是把依赖拆到原始值上:
// 依赖整个 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]
);
==== 6. 自定义 Hook 中返回稳定的对象 ====
自定义 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''(见 [[react:usecallback]])。
==== 7. 与 useCallback 的等价写法 ====
''useCallback'' 就是 ''useMemo'' 特例,缓存函数时两者可以互换:
// 完全等价
const handleClick = useCallback(() => doSomething(a), [a]);
const handleClick = useMemo(() => () => doSomething(a), [a]);
实际写代码时:**缓存函数用 ''useCallback'',缓存值用 ''useMemo''**,语义更清楚。
===== 什么时候不需要 useMemo =====
**这一节和示例同样重要。** 滥用 ''useMemo'' 的代价是:每次渲染都要比较依赖、都要占用内存保存缓存,代码还更啰嗦。对廉价计算用它,反而可能更慢。
| 情况 | 说明 |
| 计算很简单 | ''a + b''、''items.length''、拼几个字符串,直接算更快 |
| 结果没有任何人在意引用 | 只渲染成文本,不进依赖、不传给 ''memo'' 组件 |
| 依赖本身每次都变 | 缓存必然失效,写了等于白写 |
| 子组件没包 ''React.memo'' | 父组件渲染时子组件照样渲染 |
| 只是在 JSX 里写个小表达式 | 内联写最直观 |
判断标准简化成一句话:**「这个计算贵不贵?算出来的引用有没有被别人比较?」** 两个都是"是",就值得用;否则不要加。
补充:React 19 / React Compiler 能自动完成大部分记忆化,新项目里手动 ''useMemo'' 的需要在减少;但读懂现有代码里为什么这么写,仍然是必备技能。
===== 常见坑 =====
**1. 以为加了 useMemo,子组件就不会重渲染**
''useMemo'' 只保证**自己这次返回的是同一个引用**。子组件要真的跳过渲染,必须:
* 子组件用 ''React.memo'' 包裹
* **所有** prop 都稳定(有个 prop 每次新建,整层缓存就白费)
// 白费:onSelect 每次都是新函数,memo 比较失败
select(id)} />
// 正确:函数也用 useCallback 固定
**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(() => , [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 的关系 =====
| Hook | 缓存的东西 | 典型用途 |
| ''useMemo'' | **计算结果(值)** | 昂贵计算、派生数据、稳定对象/数组 |
| ''useCallback'' | **函数本身** | 传给 ''memo'' 子组件的回调、effect 依赖 |
| ''React.memo'' | **组件渲染结果** | 跳过 props 未变的子组件渲染 |
| ''useEffect'' | 不缓存 | 与外部系统同步(请求、订阅、DOM) |
| ''useRef'' | 可变容器 | 不触发渲染的值、DOM 引用 |
===== 小结 =====
* ''useMemo(fn, deps)'' 在依赖不变时**复用上次的计算结果**,不再执行 ''fn''。
* 它缓存的是**值**;''useCallback'' 缓存的是**函数**,两者是特例关系。
* 两大用途:**省掉昂贵计算**、**固定对象 / 数组引用**(让 ''useEffect''、''memo'' 不白跑)。
* 依赖用 ''Object.is'' 浅比较,**写漏会拿旧值,多写会失效**;优先依赖原始值。
* 计算函数必须是**纯函数**,副作用交给 ''useEffect''。
* **计算廉价、引用没人比较时就别用**,滥用反而是负担。
===== 相关页面 =====
* [[react:usecallback]] —— 缓存函数引用,与 useMemo 互为特例
* [[react:usestate]] —— 状态与重新渲染
* [[react:useeffect]] —— 依赖数组规则、effect 反复执行的排查
* [[react:props-state]] —— 派生数据、状态提升
* [[react:组件基础]] —— 组件、传参与数据流
* [[react:基础概念]] —— React 核心思想
```mdk height=480 color=#4f46e5
# 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
- 没有收益就不要加
```