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);
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 包裹// 白费: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 - 没有收益就不要加