React 社区长期面临一个困境:useMemo、useCallback、React.memo 这些优化手段是"正确但繁琐"的。开发者要么花大量精力手动优化,要么承受不必要的重渲染。React Compiler 的目标是将这个决策从开发者转移到编译器——让机器来决定什么需要被 memoize。
React Compiler 的设计目标
React Compiler(代号 "Forget")的核心设计目标可以用一句话概括:在编译阶段自动插入 memoization 逻辑,使组件默认具备 memo 化的渲染性能,无需手动使用 useMemo/useCallback。
这个目标背后的假设是:React 的重渲染模型本身没有问题,问题在于开发者无法精确控制什么时候应该重新计算、什么时候应该复用上次结果。React Compiler 通过静态分析组件代码,推导出每个值和函数的依赖关系,在编译输出中自动插入缓存逻辑。
// 源码:开发者写的
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>
)
}
// 编译后:编译器自动插入 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,然后分析每个变量的作用域和生命周期。核心问题是:这个值在什么条件下会变化?
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 条件 |
|---|---|---|
fullName | user.firstName, user.lastName | 任一变化时重新计算 |
avatarUrl | user.id | user.id 变化时重新计算 |
handleClick | onEdit, user.id | 任一变化时重新创建 |
2. 依赖追踪与缓存策略
编译器为每个组件函数分配一个缓存数组,按声明顺序存储 memoized 值。缓存使用 React 的 useMemoCache hook:
// 编译后(更真实的表示)
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. 引用稳定性保证
编译器最重要的能力是保证引用稳定性。在没有编译器时,以下代码会导致不必要的重渲染:
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。
// 真实的编译输出(通过 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 是需要缓存的槽位数量。每个槽位存储一个值或依赖项,通过比较前后的引用来决定是否重新计算。
与手动优化的对比
// 手动优化版
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)
function BadComponent({ items }) {
// 直接突变 props → 编译器无法追踪
items.push({ id: 4, name: 'new' })
// 突变外部变量 → 编译器放弃优化
globalCache.lastAccessed = Date.now()
return <div>{items.length}</div>
}
编译器要求所有数据遵循不可变更新模式。直接修改 props、state 或外部变量会导致编译器跳过该组件的优化。
2. 动态属性访问
function DynamicAccess({ obj, key }) {
// 动态 key 访问 → 编译器无法静态分析依赖
const value = obj[key]
return <div>{value}</div>
}
编译器无法确定 key 的值,因此无法精确追踪 obj 的哪个属性被使用。这种情况下,编译器会保守地依赖整个 obj。
3. 副作用在渲染阶段
function SideEffect({ data }) {
// 在渲染阶段执行副作用 → 编译器拒绝优化
localStorage.setItem('lastData', JSON.stringify(data))
// 在渲染阶段修改 ref → 编译器拒绝优化
const ref = useRef()
ref.current = data
return <div>{data.name}</div>
}
React 的规则是渲染阶段必须是纯函数。编译器会检测到副作用并跳过优化,同时发出警告。
4. 条件性 Hook 调用
function ConditionalHook({ enabled }) {
if (enabled) {
const [state, setState] = useState(0) // ❌ 违反 Hook 规则
}
// 编译器会报错而非跳过优化
}
迁移策略
渐进式迁移
React Compiler 支持逐步启用,不是全有或全无:
// 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:
// 迁移前
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 |
|---|---|---|---|
| 首屏渲染 | 180ms | 180ms | 180ms |
| 状态更新重渲染 | 45ms | 12ms | 9ms |
| 内存占用 | 8MB | 11MB | 10MB |
| 打包体积 | 142KB | 148KB | 146KB |
| 开发耗时(估) | 基准 | +30% | 基准 |
编译器在更新性能上略优于手动优化,主要原因是表达式级别的细粒度 memoization 比 useMemo 的块级 memoization 更精确。内存占用上,编译器比手动优化略低,因为缓存数组比多个独立的 useMemo 调用更紧凑。
与 Vue Vapor Mode 的编译策略对比
React Compiler 和 Vue Vapor Mode 都是编译器优化方案,但策略不同:
| 维度 | React Compiler | Vue 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 节点需要更新。
// 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 选择了"最小化变更"——不改变运行时模型,只在编译层叠加优化。这意味着:
- 迁移成本最低:现有代码几乎不需要改动,开启编译器即可
- 能力上限有限:自动 memoization 无法消除虚拟 DOM diff 的开销,只是在减少触发 diff 的频率
- 调试复杂性增加:编译后的代码不是源码,排查性能问题需要理解编译器行为
在实践中,我建议新项目直接启用编译器,移除所有手动 memo 代码。对于现有项目,采用渐进式迁移——先在高频更新的组件上启用,验证效果后逐步扩展。关键是不要把编译器当作"银弹":如果组件本身的设计有问题(如 props drilling 过深、状态粒度过粗),编译器无法从根本上解决性能问题。
React Compiler 解决的是"怎么 memoize"的问题,不是"怎么设计组件"的问题。好的架构设计仍然是性能的基础,编译器只是让好的架构更容易发挥性能。
小结
React Compiler 通过编译期静态分析自动插入 memoization 逻辑,在表达式级别追踪依赖关系并缓存计算结果。它消除了手动 useMemo/useCallback 的负担,生成的缓存逻辑比手写更精确。限制在于无法处理突变、动态属性访问和渲染阶段副作用。与 Vue Vapor Mode 相比,React Compiler 保留了虚拟 DOM 模型,迁移成本低但能力上限有限。务实的迁移策略是渐进式启用:新项目直接用,老项目逐步迁移,移除手动优化代码的同时关注组件设计本身的质量。
