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 模型,遷移成本低但能力上限有限。務實的遷移策略是漸進式啟用:新專案直接用,舊專案逐步遷移,移除手動最佳化程式碼的同時關注元件設計本身的品質。
