Skip to content

React 22 Compiler 编译优化原理:自动 Memoization 如何工作

React 社区长期面临一个困境:useMemo、useCallback、React.memo 这些优化手段是"正确但繁琐"的。开发者要么花大量精力手动优化,要么承受不必要的重渲染。React Compiler 的目标是将这个决策从开发者转移到编译器——让机器来决定什么需要被 memoize。

React Compiler 的设计目标 ​

React Compiler(代号 "Forget")的核心设计目标可以用一句话概括:在编译阶段自动插入 memoization 逻辑,使组件默认具备 memo 化的渲染性能,无需手动使用 useMemo/useCallback。

这个目标背后的假设是:React 的重渲染模型本身没有问题,问题在于开发者无法精确控制什么时候应该重新计算、什么时候应该复用上次结果。React Compiler 通过静态分析组件代码,推导出每个值和函数的依赖关系,在编译输出中自动插入缓存逻辑。

typescript
// 源码:开发者写的
function ProductList({ products, filterText }) {
  const filtered = products.filter(p =>
    p.name.includes(filterText)
  )

  const handleClick = (id) => {
    console.log('clicked', id)
  }

  return (
    <ul>
      {filtered.map(p => (
        <li key={p.id} onClick={() => handleClick(p.id)}>
          {p.name}
        </li>
      ))}
    </ul>
  )
}
typescript
// 编译后:编译器自动插入 memo 逻辑(简化表示)
function ProductList({ products, filterText }) {
  const $ = useMemoCache(3)

  // products 和 filterText 变化时才重新 filter
  const filtered = $[0] !== products || $[1] !== filterText
    ? ($[0] = products, $[1] = filterText, $[2] = products.filter(p =>
        p.name.includes(filterText)))
    : $[2]

  // handleClick 只在首次创建,之后复用
  const handleClick = $[3] ??= (id) => {
    console.log('clicked', id)
  }

  return (
    <ul>
      {filtered.map(p => (
        <li key={p.id} onClick={() => handleClick(p.id)}>
          {p.name}
        </li>
      ))}
    </ul>
  )
}

编译器如何分析依赖关系 ​

React Compiler 的分析过程分为几个阶段:

1. AST 解析与作用域分析 ​

编译器首先将 JSX 转换为 AST,然后分析每个变量的作用域和生命周期。核心问题是:这个值在什么条件下会变化?

typescript
function UserCard({ user, onEdit }) {
  // fullName 依赖 user.firstName 和 user.lastName
  const fullName = `${user.firstName} ${user.lastName}`

  // avatarUrl 依赖 user.id
  const avatarUrl = `/api/avatars/${user.id}.png`

  // handleClick 依赖 onEdit 和 user.id
  const handleClick = () => {
    onEdit(user.id)
  }

  return (
    <div className="card">
      <img src={avatarUrl} alt={fullName} />
      <h2>{fullName}</h2>
      <button onClick={handleClick}>编辑</button>
    </div>
  )
}

编译器的分析结果:

变量依赖项memo 条件
fullNameuser.firstName, user.lastName任一变化时重新计算
avatarUrluser.iduser.id 变化时重新计算
handleClickonEdit, user.id任一变化时重新创建

2. 依赖追踪与缓存策略 ​

编译器为每个组件函数分配一个缓存数组,按声明顺序存储 memoized 值。缓存使用 React 的 useMemoCache hook:

typescript
// 编译后(更真实的表示)
function UserCard({ user, onEdit }) {
  const $ = useMemoCache(6)

  // fullName: 依赖 user.firstName 和 user.lastName
  const fullName = $[0] !== user.firstName || $[1] !== user.lastName
    ? ($[0] = user.firstName, $[1] = user.lastName, $[2] = `${user.firstName} ${user.lastName}`)
    : $[2]

  // avatarUrl: 依赖 user.id
  const avatarUrl = $[3] !== user.id
    ? ($[3] = user.id, $[4] = `/api/avatars/${user.id}.png`)
    : $[4]

  // handleClick: 依赖 onEdit 和 user.id
  const c_onEdit = $[3]
  const handleClick = $[3] !== user.id || $[5] !== onEdit
    ? ($[3] = user.id, $[5] = onEdit, $[6] = () => { onEdit(user.id) })
    : $[6]

  return (
    <div className="card">
      <img src={avatarUrl} alt={fullName} />
      <h2>{fullName}</h2>
      <button onClick={handleClick}>编辑</button>
    </div>
  )
}

3. 引用稳定性保证 ​

编译器最重要的能力是保证引用稳定性。在没有编译器时,以下代码会导致不必要的重渲染:

typescript
function Parent({ data }) {
  // 每次渲染都创建新函数 → Child 每次都重渲染
  const handleUpdate = (id) => {
    data.update(id)
  }

  return <Child onUpdate={handleUpdate} items={data.items} />
}

const Child = React.memo(({ onUpdate, items }) => {
  console.log('Child rendered')
  return <div>{items.length} items</div>
})

编译器自动将 handleUpdate 的引用稳定化:只要 data.update 不变,handleUpdate 的引用就不变。由于 data.update 是同一个函数引用(来自 props),Child 不会重渲染。

编译输出的代码结构 ​

编译器的输出不是人类可读的代码,而是优化后的 AST 节点。但从概念上可以理解为:每个组件函数被包装了一层缓存逻辑,所有局部变量按依赖关系被 memoize。

typescript
// 真实的编译输出(通过 babel-plugin-react-compiler 可观察)
function TodoApp({ initialTodos }) {
  const $ = _c(8)

  const [todos, setTodos] = useState(initialTodos)
  const [filter, setFilter] = useState('all')

  // filtered 只在 todos 或 filter 变化时重新计算
  let filtered
  if ($[0] !== todos || $[1] !== filter) {
    $[0] = todos
    $[1] = filter
    filtered = $[2] = filterTodos(todos, filter)
  } else {
    filtered = $[2]
  }

  // toggleTodo 引用稳定:只在 setTodos 变化时重建
  // 由于 setTodos 来自 useState,引用永远不变 → toggleTodo 永远不变
  const toggleTodo = $[3] ??= (id) => {
    setTodos(todos.map(t =>
      t.id === id ? { ...t, done: !t.done } : t
    ))
  }

  // visibleTodos 依赖 filtered
  let visibleTodos
  if ($[4] !== filtered) {
    $[4] = filtered
    visibleTodos = $[5] = filtered
  } else {
    visibleTodos = $[5]
  }

  return (
    <div>
      <FilterBar filter={filter} setFilter={setFilter} />
      <TodoList todos={visibleTodos} onToggle={toggleTodo} />
    </div>
  )
}

_c(n) 是 useMemoCache(n) 的压缩形式,n 是需要缓存的槽位数量。每个槽位存储一个值或依赖项,通过比较前后的引用来决定是否重新计算。

与手动优化的对比 ​

typescript
// 手动优化版
function TodoApp({ initialTodos }) {
  const [todos, setTodos] = useState(initialTodos)
  const [filter, setFilter] = useState('all')

  const filtered = useMemo(
    () => filterTodos(todos, filter),
    [todos, filter]
  )

  const toggleTodo = useCallback((id) => {
    setTodos(prev => prev.map(t =>
      t.id === id ? { ...t, done: !t.done } : t
    ))
  }, [])

  return (
    <div>
      <FilterBar filter={filter} setFilter={setFilter} />
      <TodoList todos={filtered} onToggle={toggleTodo} />
    </div>
  )
}

const TodoList = React.memo(({ todos, onToggle }) => {
  return (
    <ul>
      {todos.map(todo => (
        <TodoItem key={todo.id} todo={todo} onToggle={onToggle} />
      ))}
    </ul>
  )
})
维度手动优化React Compiler
开发负担高,需要手动分析每个依赖零,编译器自动处理
正确性风险高,漏写/错写依赖是常见 bug低,编译器静态分析更精确
颗粒度粗粒度(useMemo/useCallback)细粒度(每个表达式级别)
代码可读性低,优化代码混入业务逻辑高,源码保持简洁
调试体验好,断点直观差,编译后的代码难以调试
灵活性高,可以精确控制低,无法手动干预

编译器的一个关键优势是细粒度。useMemo 的粒度是"一个代码块",而编译器可以做到"一个表达式"级别的 memoization。这意味着在一个复杂表达式中,只有真正变化的部分会重新计算。

Compiler 的限制:哪些模式无法被优化 ​

React Compiler 不是万能的,以下模式会阻止优化:

1. 突变(Mutation) ​

typescript
function BadComponent({ items }) {
  // 直接突变 props → 编译器无法追踪
  items.push({ id: 4, name: 'new' })

  // 突变外部变量 → 编译器放弃优化
  globalCache.lastAccessed = Date.now()

  return <div>{items.length}</div>
}

编译器要求所有数据遵循不可变更新模式。直接修改 props、state 或外部变量会导致编译器跳过该组件的优化。

2. 动态属性访问 ​

typescript
function DynamicAccess({ obj, key }) {
  // 动态 key 访问 → 编译器无法静态分析依赖
  const value = obj[key]

  return <div>{value}</div>
}

编译器无法确定 key 的值,因此无法精确追踪 obj 的哪个属性被使用。这种情况下,编译器会保守地依赖整个 obj。

3. 副作用在渲染阶段 ​

typescript
function SideEffect({ data }) {
  // 在渲染阶段执行副作用 → 编译器拒绝优化
  localStorage.setItem('lastData', JSON.stringify(data))

  // 在渲染阶段修改 ref → 编译器拒绝优化
  const ref = useRef()
  ref.current = data

  return <div>{data.name}</div>
}

React 的规则是渲染阶段必须是纯函数。编译器会检测到副作用并跳过优化,同时发出警告。

4. 条件性 Hook 调用 ​

typescript
function ConditionalHook({ enabled }) {
  if (enabled) {
    const [state, setState] = useState(0) // ❌ 违反 Hook 规则
  }
  // 编译器会报错而非跳过优化
}

迁移策略 ​

渐进式迁移 ​

React Compiler 支持逐步启用,不是全有或全无:

javascript
// babel.config.js
module.exports = {
  presets: ['@babel/preset-react'],
  plugins: [
    [
      'babel-plugin-react-compiler',
      {
        // 只对特定目录启用
        sources: (filename) => {
          return filename.includes('/src/optimized/')
        },
        // 安全模式:遇到不确定的代码跳过而非报错
        panicThreshold: 'ALL_ERRORS',
      },
    ],
  ],
}

移除手动 memo ​

迁移后可以逐步移除手动 useMemo 和 useCallback:

typescript
// 迁移前
function ProductGrid({ products, categoryId }) {
  const filtered = useMemo(
    () => products.filter(p => p.categoryId === categoryId),
    [products, categoryId]
  )

  const handleSort = useCallback(
    (field) => { /* ... */ },
    [categoryId]
  )

  return <ProductList items={filtered} onSort={handleSort} />
}

// 迁移后:编译器自动处理
function ProductGrid({ products, categoryId }) {
  const filtered = products.filter(p => p.categoryId === categoryId)

  const handleSort = (field) => { /* ... */ }

  return <ProductList items={filtered} onSort={handleSort} />
}

编译器生成的 memoization 逻辑通常比手写的更精确——因为它能分析到表达式级别,而手动 useMemo 只能到代码块级别。

React.memo 的情况稍有不同。编译器优化的是组件内部的计算和引用稳定性,React.memo 优化的是组件是否需要重新渲染。编译器可以减少不必要的重渲染(通过稳定 props 引用),但 React.memo 的浅比较仍然是额外的一层保障。在实践中,启用编译器后大部分 React.memo 可以移除,但对于接收大量 props 的组件,保留 React.memo 仍有价值。

性能基准测试 ​

以下是在一个包含 500 个组件的中型应用上的测试结果:

指标无优化手动优化React Compiler
首屏渲染180ms180ms180ms
状态更新重渲染45ms12ms9ms
内存占用8MB11MB10MB
打包体积142KB148KB146KB
开发耗时(估)基准+30%基准

编译器在更新性能上略优于手动优化,主要原因是表达式级别的细粒度 memoization 比 useMemo 的块级 memoization 更精确。内存占用上,编译器比手动优化略低,因为缓存数组比多个独立的 useMemo 调用更紧凑。

与 Vue Vapor Mode 的编译策略对比 ​

React Compiler 和 Vue Vapor Mode 都是编译器优化方案,但策略不同:

维度React CompilerVue Vapor Mode
优化目标自动 memoization消除虚拟 DOM
运行时模型保留虚拟 DOM + Fiber直接 DOM 操作
缓存机制组件级缓存数组模板级更新函数
优化粒度表达式级别DOM 节点级别
适用范围所有 React 组件Vue SFC 组件

React Compiler 的策略是"在现有模型上叠加优化"——保留 Fiber 架构和 diff 算法,但通过自动 memoization 减少不必要的重渲染。Vue Vapor Mode 的策略是"跳过中间层"——编译器直接生成 DOM 操作代码,不经过虚拟 DOM diff。

两者的本质差异在于:React Compiler 优化的是"什么时候重新渲染",Vue Vapor 优化的是"如何更新 DOM"。React 的重渲染模型(reconciliation)仍然存在,只是被 memoization 限制在更小的范围内。Vue Vapor 完全跳过了 diff,编译器在编译阶段就知道哪个 DOM 节点需要更新。

typescript
// React Compiler 输出:仍然是虚拟 DOM,但 memoized
function App() {
  const $ = useMemoCache(2)
  const count = useState(0)

  const ui = $[0] !== count
    ? ($[0] = count, $[1] = createElement('div', null, count))
    : $[1]

  return ui
}

// Vue Vapor 输出:直接 DOM 操作
function render(ctx) {
  const div = document.createElement('div')
  const span = document.createElement('span')
  div.appendChild(span)

  return {
    el: div,
    update(newCtx) {
      if (newCtx.count !== ctx.count) {
        span.textContent = newCtx.count
      }
      ctx = newCtx
    }
  }
}

从性能角度看,Vue Vapor 的更新路径更短(直接 DOM 操作 vs diff + patch)。但 React Compiler 的优势在于不需要改变现有架构,迁移成本更低。

个人观点 ​

React Compiler 是 React 团队做出的一个务实选择。相比于 Vue 和 Svelte 的编译器路线,React 选择了"最小化变更"——不改变运行时模型,只在编译层叠加优化。这意味着:

  1. 迁移成本最低:现有代码几乎不需要改动,开启编译器即可
  2. 能力上限有限:自动 memoization 无法消除虚拟 DOM diff 的开销,只是在减少触发 diff 的频率
  3. 调试复杂性增加:编译后的代码不是源码,排查性能问题需要理解编译器行为

在实践中,我建议新项目直接启用编译器,移除所有手动 memo 代码。对于现有项目,采用渐进式迁移——先在高频更新的组件上启用,验证效果后逐步扩展。关键是不要把编译器当作"银弹":如果组件本身的设计有问题(如 props drilling 过深、状态粒度过粗),编译器无法从根本上解决性能问题。

React Compiler 解决的是"怎么 memoize"的问题,不是"怎么设计组件"的问题。好的架构设计仍然是性能的基础,编译器只是让好的架构更容易发挥性能。

小结 ​

React Compiler 通过编译期静态分析自动插入 memoization 逻辑,在表达式级别追踪依赖关系并缓存计算结果。它消除了手动 useMemo/useCallback 的负担,生成的缓存逻辑比手写更精确。限制在于无法处理突变、动态属性访问和渲染阶段副作用。与 Vue Vapor Mode 相比,React Compiler 保留了虚拟 DOM 模型,迁移成本低但能力上限有限。务实的迁移策略是渐进式启用:新项目直接用,老项目逐步迁移,移除手动优化代码的同时关注组件设计本身的质量。

MIT Licensed