====== 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 (
setKeyword(e.target.value)} />
); }
组件因为别的原因重新渲染时(比如父组件刷新、某个无关的 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 - 没有收益就不要加 ```