react:usememo

差别

这里会显示出您选择的修订版和当前版本之间的差别。

到此差别页面的链接

后一修订版
前一修订版
react:usememo [2026/11/09 14:27] – 创建 张叶安react:usememo [2026/11/09 14:28] (当前版本) – 为 useMemo 页面添加思维导图 张叶安
行 1: 行 1:
-1+====== useMemo ====== 
 + 
 +''useMemo'' 是 React 提供的一个 **Hook(钩子)**,用来**在多次渲染之间缓存一次计算的结果**。依赖项没变时直接复用上次的值,不再重新计算。 
 + 
 +一句话概括:**「依赖没变,就别再算了,把上次的结果给我。」** 
 + 
 +要注意它**不是让计算变快的开关**,而是**避免重复执行本可以不执行的计算**。真正的收益来自「少算」,而不是「算得快」。 
 + 
 +===== 一句话理解 ===== 
 + 
 +<code javascript> 
 +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> 
 +  ); 
 +} 
 +</code> 
 + 
 +组件因为别的原因重新渲染时(比如父组件刷新、某个无关的 state 变化),只要 ''products'' 和 ''keyword'' 没变,''useMemo'' 就直接返回上次的结果,跳过整个 ''filter''。 
 + 
 +===== 基本语法 ===== 
 + 
 +<code javascript> 
 +const value = useMemo(createFn, deps); 
 +</code> 
 + 
 +  * **第一个参数**:计算函数,**必须 return 一个值** 
 +  * **第二个参数**:**依赖数组**,里面任一项变化时才重新执行计算函数 
 +  * **返回值**:缓存下来的计算结果 
 + 
 +<code javascript> 
 +const total = useMemo(() => items.length, [items]); 
 +const sorted = useMemo(() => [...list].sort((a, b) => a - b), [list]); 
 +const options = useMemo(() => ({ page, size }), [page, size]); 
 +</code> 
 + 
 +和所有 Hook 一样,''useMemo'' 必须写在组件或自定义 Hook 的**最顶层**,不能放在条件、循环、嵌套函数里。 
 + 
 +===== 依赖数组 ===== 
 + 
 +| 写法 | 行为 | 适用场景 | 
 +| ''[]'' | 只计算一次,之后一直复用 | 计算不依赖任何会变的值 | 
 +| ''[a, b]'' | a 或 b 变化时重新计算 | 计算用到了 a、b | 
 +| 不传 | 每次渲染都重新计算,等于没缓存 | 没有意义,别这么写 | 
 + 
 +**依赖是 ''Object.is'' 浅比较**,和 ''useEffect'' 规则完全一致:用到了什么就必须写什么,写漏会拿到旧值,多写会让缓存失效。 
 + 
 +===== 具体用法示例 ===== 
 + 
 +==== 1. 缓存昂贵计算:过滤 + 排序大列表 ==== 
 + 
 +最典型也最正当的场景。''filter''、''sort''、正则匹配、复杂映射在大数据量下开销明显: 
 + 
 +<code javascript> 
 +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> 
 +  ); 
 +} 
 +</code> 
 + 
 +注意这里的关键点:''selected'' 变化时组件会重渲染,但它**不在依赖里**,所以过滤排序被完全跳过——这正是收益所在。 
 + 
 +==== 2. 派生数据:购物车总价 ==== 
 + 
 +由现有状态推导出来的数据,用 ''useMemo'' 包一层,避免每次渲染都遍历一遍: 
 + 
 +<code javascript> 
 +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> 
 +  ); 
 +} 
 +</code> 
 + 
 +这类数据**绝不能放进 ''useState''**,它就是「由 state 算出来的」,算就是了(参考 [[react:props-state]])。 
 + 
 +==== 3. 保持对象 / 数组引用稳定:作为其他 Hook 的依赖 ==== 
 + 
 +这是**比性能优化更重要的用途**。每次渲染都新建的对象,会让依赖它的 ''useEffect'' 每次渲染都重新执行: 
 + 
 +<code javascript> 
 +// 问题: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 就不重跑 
 +} 
 +</code> 
 + 
 +同样的道理适用于把对象、数组作为 ''useMemo'' / ''useCallback'' 的依赖,或作为 ''useCallback'' 内部读取的值。 
 + 
 +==== 4. 传给 React.memo 子组件的对象 prop ==== 
 + 
 +''React.memo'' 做的是**浅比较**。传下去的 prop 如果是每次渲染新建的对象或数组,''memo'' 就完全失效: 
 + 
 +<code javascript> 
 +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} /> 
 +    </> 
 +  ); 
 +} 
 +</code> 
 + 
 +切换 ''tab'' 时 ''data''、''style'' 引用不变,''Chart'' 就会被 ''memo'' 拦下来,不重新渲染。 
 + 
 +==== 5. 依赖对象的具体字段,而不是整个对象 ==== 
 + 
 +依赖越"细",缓存命中率越高。做法是把依赖拆到原始值上: 
 + 
 +<code javascript> 
 +// 依赖整个 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] 
 +); 
 +</code> 
 + 
 +==== 6. 自定义 Hook 中返回稳定的对象 ==== 
 + 
 +自定义 Hook 返回的对象如果每次都是新的,调用方只要把它放进依赖就会反复触发: 
 + 
 +<code javascript> 
 +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] 
 +  ); 
 +} 
 +</code> 
 + 
 +严格来说 ''next'' 这里每次也会重建,若要彻底稳定,再配一个 ''useCallback''(见 [[react:usecallback]])。 
 + 
 +==== 7. 与 useCallback 的等价写法 ==== 
 + 
 +''useCallback'' 就是 ''useMemo'' 特例,缓存函数时两者可以互换: 
 + 
 +<code javascript> 
 +// 完全等价 
 +const handleClick = useCallback(() => doSomething(a), [a]); 
 +const handleClick = useMemo(() => () => doSomething(a), [a]); 
 +</code> 
 + 
 +实际写代码时:**缓存函数用 ''useCallback'',缓存值用 ''useMemo''**,语义更清楚。 
 + 
 +===== 什么时候不需要 useMemo ===== 
 + 
 +**这一节和示例同样重要。** 滥用 ''useMemo'' 的代价是:每次渲染都要比较依赖、都要占用内存保存缓存,代码还更啰嗦。对廉价计算用它,反而可能更慢。 
 + 
 +| 情况 | 说明 | 
 +| 计算很简单 | ''a + b''、''items.length''、拼几个字符串,直接算更快 | 
 +| 结果没有任何人在意引用 | 只渲染成文本,不进依赖、不传给 ''memo'' 组件 | 
 +| 依赖本身每次都变 | 缓存必然失效,写了等于白写 | 
 +| 子组件没包 ''React.memo'' | 父组件渲染时子组件照样渲染 | 
 +| 只是在 JSX 里写个小表达式 | 内联写最直观 | 
 + 
 +判断标准简化成一句话:**「这个计算贵不贵?算出来的引用有没有被别人比较?」** 两个都是"是",就值得用;否则不要加。 
 + 
 +补充:React 19 / React Compiler 能自动完成大部分记忆化,新项目里手动 ''useMemo'' 的需要在减少;但读懂现有代码里为什么这么写,仍然是必备技能。 
 + 
 +===== 常见坑 ===== 
 + 
 +**1. 以为加了 useMemo,子组件就不会重渲染** 
 + 
 +''useMemo'' 只保证**自己这次返回的是同一个引用**。子组件要真的跳过渲染,必须: 
 + 
 +  * 子组件用 ''React.memo'' 包裹 
 +  * **所有** prop 都稳定(有个 prop 每次新建,整层缓存就白费) 
 + 
 +<code javascript> 
 +// 白费:onSelect 每次都是新函数,memo 比较失败 
 +<List data={data} onSelect={id => select(id)} /> 
 + 
 +// 正确:函数也用 useCallback 固定 
 +<List data={data} onSelect={handleSelect} /> 
 +</code> 
 + 
 +**2. 依赖写漏 → 拿到旧值** 
 + 
 +''useMemo'' 缓存的是**当时的闭包快照**,依赖没写全,读到的就是旧数据: 
 + 
 +<code javascript> 
 +const [keyword, setKeyword] = useState(''); 
 + 
 +// 用到了 keyword,却忘了写进依赖 → 永远是第一次的过滤结果 
 +const filtered = useMemo(() => list.filter(i => i.name.includes(keyword)), [list]); 
 +</code> 
 + 
 +用 ESLint 的 ''react-hooks/exhaustive-deps'' 规则可以自动检查。 
 + 
 +**3. 依赖里放了每次新建的对象** 
 + 
 +<code javascript> 
 +const style = { color: 'red' };                 // 每次渲染都是新对象 
 +const node = useMemo(() => <Box style={style} />, [style]);  // 缓存永远失效 
 + 
 +const style = useMemo(() => ({ color: 'red' }), []);         // 先把它固定住 
 +</code> 
 + 
 +**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 
 +- 没有收益就不要加 
 +``` 

该主题尚不存在

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

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