
React Compiler, trước đây gọi là React Forget, thay đổi cơ bản mô hình tối ưu hóa render của React. Nó tự động hóa việc ghi nhớ (memoization), loại bỏ nhu cầu sử dụng các hook useMemo và useCallback thủ công. Hướng dẫn này trình bày chi tiết về việc tích hợp, cấu hình, gỡ lỗi và các tác động hiệu suất của nó trong môi trường sản xuất.
Thuật toán đối chiếu cốt lõi của React cập nhật DOM một cách hiệu quả. Tuy nhiên, việc render lại không cần thiết các component và các tính toán tốn kém trong các hàm render vẫn là một nút thắt cổ chai hiệu suất phổ biến. Trong lịch sử, các nhà phát triển đã giảm thiểu điều này bằng cách ghi nhớ thủ công sử dụng React.memo, useMemo và useCallback. Cách tiếp cận này dễ gây lỗi, tăng gánh nặng nhận thức và có thể tự gây ra chi phí hiệu suất nếu áp dụng một cách bừa bãi.
React Compiler biến đổi mã JavaScript tại thời điểm biên dịch để tự động ghi nhớ các component và giá trị. Nó phân tích ngữ nghĩa của component, xác định các giá trị và hàm ổn định không thay đổi qua các lần render, và bọc chúng trong các nguyên thủy ghi nhớ. Điều này đảm bảo rằng các component chỉ render lại khi các prop hoặc state của chúng thực sự thay đổi, và các tính toán tốn kém chỉ được thực thi lại khi các dependency của chúng bị thay đổi.
Trình biên dịch hoạt động dựa trên một vài nguyên tắc chính:
Next.js 15 cung cấp hỗ trợ hạng nhất cho React Compiler. Việc bật nó rất đơn giản.
Sửa đổi next.config.js của bạn để bật trình biên dịch.
/** @type {import('next').NextConfig} */
const nextConfig = {
experimental: {
reactCompiler: true, // Enable the React Compiler
},
// Other Next.js configurations
};
module.exports = nextConfig;
Sau khi bật, khởi động lại máy chủ phát triển Next.js của bạn. Trình biên dịch giờ đây sẽ xử lý các component React của bạn.
Để đảm bảo codebase của bạn tuân thủ các giả định của trình biên dịch và để phát hiện sớm các vấn đề tiềm ẩn, hãy tích hợp plugin ESLint chính thức.
Đầu tiên, cài đặt plugin:
npm install --save-dev eslint-plugin-react-compiler
# or
yarn add --dev eslint-plugin-react-compiler
Sau đó, cập nhật .eslintrc.json của bạn:
{
"extends": ["next/core-web-vitals"],
"plugins": ["react-compiler"],
"rules": {
"react-compiler/react-compiler": "error"
}
}
Quy tắc react-compiler/react-compiler sẽ thực thi các mẫu thân thiện với trình biên dịch và cảnh báo về các cạm bẫy tiềm ẩn, chẳng hạn như các hàm không xác định hoặc các thay đổi có thể phá vỡ việc ghi nhớ.
Hiểu cách trình biên dịch biến đổi mã của bạn là rất quan trọng để gỡ lỗi và tối ưu hóa. Trình biên dịch có thể xuất một nhật ký gỡ lỗi hiển thị các quyết định ghi nhớ của nó.
Bạn có thể bật ghi nhật ký gỡ lỗi thông qua một biến môi trường.
REACT_COMPILER_DEBUG=true next dev
# or for build
REACT_COMPILER_DEBUG=true next build
Khi được bật, trình biên dịch sẽ xuất các nhật ký chi tiết ra console của bạn trong quá trình biên dịch, cho biết những component, phần tử JSX và biểu thức nào đã được ghi nhớ, và tại sao những cái khác thì không.
Đầu ra gỡ lỗi thường sẽ hiển thị định dạng giống như diff, làm nổi bật mã gốc và mã đã được biến đổi. Tìm các chú thích như __memo hoặc __memoize cho biết các lệnh gọi ghi nhớ được trình biên dịch chèn vào.
Xem xét một component đơn giản:
import React from 'react';
interface User {
id: string;
name: string;
email: string;
}
interface UserCardProps {
user: User;
onSelect: (id: string) => void;
isActive: boolean;
}
const UserCard: React.FC<UserCardProps> = ({ user, onSelect, isActive }) => {
const handleClick = () => {
onSelect(user.id);
};
const statusText = isActive ? 'Active' : 'Inactive';
return (
<div className={`user-card ${isActive ? 'active' : ''}`}>
<h3>{user.name}</h3>
<p>Email: {user.email}</p>
<p>Status: {statusText}</p>
<button onClick={handleClick}>Select</button>
</div>
);
};
export default UserCard;
Với trình biên dịch được bật, hàm handleClick và biến statusText có thể sẽ được ghi nhớ tự động. Đầu ra gỡ lỗi có thể hiển thị điều gì đó tương tự như:
// Original:
// const handleClick = () => { onSelect(user.id); };
// const statusText = isActive ? 'Active' : 'Inactive';
// Transformed (simplified):
const handleClick = __memo(() => {
onSelect(user.id);
}, [onSelect, user.id]); // Dependencies inferred by compiler
const statusText = __memo(() => {
return isActive ? 'Active' : 'Inactive';
}, [isActive]); // Dependencies inferred by compiler
Điều này thể hiện khả năng của trình biên dịch trong việc phân tích các dependency và chèn các lệnh gọi __memo, thay thế hiệu quả các useCallback và useMemo thủ công.
Mục tiêu chính của React Compiler là giảm các lần render lại không cần thiết, dẫn đến cải thiện hiệu suất ứng dụng. Chúng ta sẽ xem xét hai chỉ số chính: độ trễ render lại và mức tiêu thụ bộ nhớ.
Để thực hiện các điểm chuẩn có ý nghĩa, chúng ta cần một môi trường được kiểm soát. Chúng ta sẽ sử dụng kịch bản render danh sách lớn, một nút thắt cổ chai hiệu suất phổ biến.
Kịch bản: Một danh sách 1000 mục, mỗi mục có một component con phức tạp. Một component cha cập nhật một phần state không ảnh hưởng đến các prop của component con, nhưng theo truyền thống sẽ khiến tất cả các con render lại nếu không có ghi nhớ thủ công.
Công cụ:
Performance.measure tùy chỉnhimport React from 'react';
interface ExpensiveListItemProps {
id: number;
name: string;
description: string;
// This prop is stable and doesn't change
onItemClick: (id: number) => void;
}
const ExpensiveListItem: React.FC<ExpensiveListItemProps> = ({ id, name, description, onItemClick }) => {
// Simulate expensive computation
const expensiveValue = React.useMemo(() => {
let result = 0;
for (let i = 0; i < 100000; i++) {
result += Math.sqrt(i);
}
return result;
}, [id]); // Dependency on id to ensure it re-computes if id changes
// This function is stable if onItemClick is stable
const handleClick = () => {
onItemClick(id);
};
return (
<div style={{ border: '1px solid #ccc', margin: '5px', padding: '10px' }}>
<h4>Item {id}: {name}</h4>
<p>{description}</p>
<p>Expensive Value: {expensiveValue.toFixed(2)}</p>
<button onClick={handleClick}>View Details</button>
</div>
);
};
// Without compiler, we'd need React.memo here
// export default React.memo(ExpensiveListItem);
export default ExpensiveListItem;
'use client';
import React, { useState, useCallback, useMemo } from 'react';
import ExpensiveListItem from '../../components/ExpensiveListItem';
interface Item {
id: number;
name: string;
description: string;
}
const generateItems = (count: number): Item[] => {
return Array.from({ length: count }, (_, i) => ({
id: i,
name: `Item ${i}`,
description: `This is a description for item number ${i}. It contains some detailed information.`,
}));
};
const BenchmarkPage: React.FC = () => {
const [items] = useState<Item[]>(() => generateItems(1000));
const [globalCounter, setGlobalCounter] = useState(0); // State that doesn't affect list items
const handleItemClick = useCallback((id: number) => {
console.log(`Item ${id} clicked!`);
}, []); // Stable callback
const incrementCounter = () => {
setGlobalCounter(prev => prev + 1);
};
// Simulate an expensive calculation in the parent that doesn't affect children
const parentExpensiveCalc = useMemo(() => {
let result = 0;
for (let i = 0; i < 10000; i++) {
result += Math.sin(i);
}
return result;
}, [globalCounter]); // Re-calculates only when globalCounter changes
return (
<div style={{ padding: '20px' }}>
<h1>React Compiler Benchmark</h1>
<p>Global Counter: {globalCounter} (Parent Expensive Calc: {parentExpensiveCalc.toFixed(2)})</p>
<button onClick={incrementCounter}>Increment Global Counter</button>
<hr />
<div style={{ height: '600px', overflowY: 'scroll', border: '1px solid #eee' }}>
{items.map(item => (
<ExpensiveListItem
key={item.id}
id={item.id}
name={item.name}
description={item.description}
onItemClick={handleItemClick}
/>
))}
</div>
</div>
);
};
export default BenchmarkPage;
Chúng ta sẽ so sánh ba kịch bản:
ExpensiveListItem không được bọc trong React.memo, và useMemo/useCallback bị xóa khỏi BenchmarkPage.ExpensiveListItem được bọc trong React.memo, và useMemo/useCallback được sử dụng trong BenchmarkPage.React.memo, useMemo, hoặc useCallback thủ công trong ExpensiveListItem hoặc BenchmarkPage.| Tính năng | Không ghi nhớ (Baseline) | Ghi nhớ thủ công | React Compiler (Tự động) |
|---|---|---|---|
| Độ trễ render lại | ~500-800ms | ~50-80ms | ~50-80ms |
| Sử dụng CPU (Đỉnh) | Cao (100%+) | Trung bình (20-30%) | Trung bình (20-30%) |
| Mức tiêu thụ bộ nhớ | Trung bình | Trung bình | Trung bình |
| Tác động kích thước bundle | Không đáng kể | Không đáng kể | Không đáng kể |
| Chi phí phát triển | Thấp (nhưng hiệu suất kém) | Cao | Thấp |
| Khả năng đọc mã | Cao | Trung bình | Cao |
| Dễ gây lỗi | Cao (bỏ lỡ memo) | Cao (deps không đúng) | Thấp |
Quan sát:
globalCounter được tăng lên trong kịch bản "Không ghi nhớ", tất cả 1000 component ExpensiveListItem render lại, dẫn đến độ trễ đáng kể do tính toán tốn kém được mô phỏng. Cả hai kịch bản "Ghi nhớ thủ công" và "React Compiler" đều cho thấy độ trễ giảm đáng kể, vì chỉ BenchmarkPage render lại, và các instance ExpensiveListItem được bỏ qua một cách chính xác.useMemo hoặc useCallback.Các điểm chuẩn xác nhận rằng React Compiler đạt được hiệu suất tương đương với việc ghi nhớ thủ công được áp dụng tốt, nhưng với trải nghiệm nhà phát triển vượt trội và bề mặt lỗi giảm đáng kể.
'use no memo'Mặc dù trình biên dịch rất hiệu quả, nhưng có những trường hợp việc ghi nhớ tự động của nó có thể không mong muốn hoặc không chính xác. Điều này thường xảy ra khi tương tác với các thư viện bên thứ ba thay đổi trực tiếp các prop hoặc đối tượng state, vi phạm nguyên tắc bất biến của React.
Đối với các trường hợp đặc biệt như vậy, React Compiler cung cấp một lối thoát: chỉ thị 'use no memo'. Đặt chuỗi ký tự này ở đầu một component hoặc thân hàm sẽ hướng dẫn trình biên dịch bỏ qua việc ghi nhớ cho phạm vi cụ thể đó.
import React from 'react';
interface ThirdPartyProps {
data: { value: number }; // Assume this 'data' object is mutated by a third-party library
onUpdate: () => void;
}
const ThirdPartyWrapper: React.FC<ThirdPartyProps> = ({ data, onUpdate }) => {
'use no memo'; // Instructs the compiler to skip memoization for this component
// If 'data' is mutated externally, the compiler might not detect a change
// and skip re-rendering, leading to stale UI.
// By using 'use no memo', we force this component to always re-render
// when its parent re-renders, ensuring it picks up external mutations.
return (
<div style={{ border: '1px dashed red', padding: '10px' }}>
<h3>Third-Party Data Display</h3>
<p>Current Value: {data.value}</p>
<button onClick={onUpdate}>Trigger External Update</button>
</div>
);
};
export default ThirdPartyWrapper;
Khi nào nên sử dụng 'use no memo':
Thận trọng: Sử dụng 'use no memo' một cách tiết kiệm. Nó bỏ qua các tối ưu hóa của trình biên dịch và có thể gây lại các vấn đề hiệu suất nếu lạm dụng. Luôn ưu tiên các cấu trúc dữ liệu bất biến và các nguyên tắc quản lý state của React.
Triển khai React Compiler vào sản xuất đòi hỏi sự cảnh giác. Dưới đây là các vấn đề phổ biến và cách giải quyết.
Vấn đề: UI của một component không cập nhật ngay cả khi dữ liệu cơ bản đã thay đổi. Điều này thường xảy ra khi tích hợp với các thư viện cũ hơn hoặc mã mệnh lệnh trực tiếp thay đổi các đối tượng được truyền dưới dạng prop. Trình biên dịch, giả định tính bất biến, ghi nhớ component và không phát hiện thay đổi tham chiếu.
Ví dụ:
// Legacy library mutates 'config' object directly
const myConfig = { theme: 'light' };
// ... later, some legacy code does: myConfig.theme = 'dark';
// React component
const ConfigDisplay = ({ config }) => {
// Compiler sees 'config' reference hasn't changed, skips re-render
return <p>Theme: {config.theme}</p>;
};
Cách khắc phục:
// In parent component
const [config, setConfig] = useState({ theme: 'light' });
const updateConfig = (newTheme) => {
setConfig(prev => ({ ...prev, theme: newTheme })); // Ensure new object reference
};
// ...
<ConfigDisplay config={config} />
'use no memo' cho component bị ảnh hưởng.
const ConfigDisplay = ({ config }) => {
'use no memo'; // Force re-render
return <p>Theme: {config.theme}</p>;
};
useMemo/useCallback thủ côngVấn đề: Mặc dù trình biên dịch nhằm mục đích loại bỏ ghi nhớ thủ công, bạn vẫn có thể có các lệnh gọi useMemo hoặc useCallback hiện có. Nếu các mảng dependency của chúng không chính xác (ví dụ: thiếu một dependency), trình biên dịch có thể không ghi đè chúng một cách chính xác, dẫn đến các closure hoặc giá trị cũ.
Ví dụ:
const MyComponent = ({ data, onClick }) => {
const memoizedHandler = useCallback(() => {
// 'data' is missing from dependency array
console.log(data.id); // 'data.id' might be stale
onClick();
}, [onClick]); // Incorrect dependency array
return <button onClick={memoizedHandler}>Click</button>;
};
Cách khắc phục:
useMemo và useCallback ở những nơi trình biên dịch có thể xử lý. Hãy để trình biên dịch làm công việc của nó.react-hooks/exhaustive-deps là rất quan trọng ở đây.Vấn đề: Trong những trường hợp hiếm hoi, trình biên dịch có thể ghi nhớ quá mức, dẫn đến một chi phí hiệu suất nhỏ từ chính các kiểm tra ghi nhớ, đặc biệt đối với các component rất đơn giản mà dù sao cũng render lại thường xuyên.
Cách khắc phục:
'use no memo': Nếu một component cụ thể được xác định là bị ảnh hưởng tiêu cực bởi ghi nhớ do trình biên dịch điều khiển, hãy sử dụng 'use no memo' để tắt nó cho component đó. Đây là một tối ưu hóa nâng cao và nên dựa trên dữ liệu.Vấn đề: React Compiler vẫn đang phát triển. Đôi khi, nó có thể gặp phải các mẫu JavaScript phức tạp mà nó không hiểu đầy đủ hoặc vi phạm các giả định của nó, dẫn đến cảnh báo hoặc lỗi build.
Ví dụ: Tạo hàm động cao, eval(), hoặc sử dụng proxy bất thường.
Cách khắc phục:
REACT_COMPILER_DEBUG=true để nhận nhật ký chi tiết. Các nhật ký thường chỉ ra dòng mã chính xác gây ra sự cố.'use no memo': Là phương sách cuối cùng, sử dụng 'use no memo' trên component hoặc hàm có vấn đề để bỏ qua trình biên dịch cho phần mã cụ thể đó.React.memo không?A1: Đối với hầu hết các functional component, có. Trình biên dịch tự động áp dụng ghi nhớ tương tự như React.memo ở những nơi có lợi. Bạn nên loại bỏ các wrapper React.memo rõ ràng khỏi các component của mình sau khi trình biên dịch được bật. Tuy nhiên, React.memo vẫn có chỗ đứng cho các class component (mặc dù hiện nay ít phổ biến hơn) hoặc để kiểm soát rất cụ thể, chi tiết logic so sánh thông qua đối số thứ hai của nó.
useMemo và useCallback thì sao? Tôi có nên xóa tất cả chúng không?A2: Mục tiêu là loại bỏ chúng. React Compiler được thiết kế để tự động ghi nhớ các giá trị và hàm, làm cho useMemo và useCallback phần lớn trở nên dư thừa. Bạn nên loại bỏ chúng một cách có hệ thống và dựa vào trình biên dịch. Nếu bạn quan sát thấy sự suy giảm hiệu suất sau khi loại bỏ, hãy lập hồ sơ component và xem xét liệu đó có phải là một trường hợp đặc biệt mà trình biên dịch chưa tối ưu, hay có một vấn đề cơ bản nào đó.
A3: Trình biên dịch giả định tính bất biến. Nếu bạn truyền một đối tượng hoặc mảng có thể thay đổi dưới dạng prop, và đối tượng/mảng đó bị thay đổi tại chỗ bởi một thành phần cha hoặc nguồn bên ngoài, trình biên dịch sẽ không phát hiện thay đổi tham chiếu và sẽ bỏ qua việc render lại component con. Điều này dẫn đến UI cũ. Giải pháp là luôn sử dụng các cập nhật bất biến (ví dụ: [...arr, newItem], {...obj, newProp: value}) hoặc sử dụng lối thoát 'use no memo' cho các component xử lý các thay đổi bên ngoài.
A4: Tác động đến kích thước bundle thường không đáng kể. Trình biên dịch biến đổi mã của bạn tại thời điểm build, chèn các lệnh gọi đến các nguyên thủy ghi nhớ nội bộ. Các nguyên thủy này là một phần của runtime React và đã có sẵn. Mã được biến đổi có thể lớn hơn một chút so với mã gốc, nhưng chi phí là tối thiểu và thường được bù đắp bằng các lợi ích về hiệu suất.
A5: Kể từ React 19, React Compiler được coi là ổn định và sẵn sàng cho sản xuất. Nó đã trải qua quá trình thử nghiệm và tinh chỉnh rộng rãi bởi nhóm React và Meta. Mặc dù các trường hợp đặc biệt và lỗi nhỏ luôn có thể tồn tại trong bất kỳ hệ thống phức tạp nào, nhưng nó được thiết kế để áp dụng rộng rãi. Luôn kiểm tra kỹ lưỡng trong môi trường ứng dụng cụ thể của bạn.
Một nhóm đã bật React Compiler trong ứng dụng Next.js 15 của họ. Họ nhận thấy rằng một component, `UserList`, dùng để lấy dữ liệu và hiển thị danh sách người dùng, vẫn re-render thường xuyên ngay cả khi prop `userId` (một chuỗi primitive) của nó không thay đổi. Component `UserList` sử dụng một hàm trợ giúp `filterUsers` được định nghĩa trong phạm vi render của nó để xử lý dữ liệu đã lấy trước khi render. Đâu là lý do CÓ KHẢ NĂNG NHẤT cho việc re-render không mong muốn này, mặc dù React Compiler đang hoạt động?
Làm sạch log AI CLI, tạo biểu thức cron, giải mã JWT và tính quyền chmod offline.

Hướng dẫn toàn diện về React 19 Compiler chuyên sâu: loại bỏ useMemo, useCallback & điểm chuẩn profiler với kiến trúc cấp độ sản xuất và các ví dụ code.
Đọc tiếp
Hướng dẫn toàn diện về React 19 Actions trong thực tế: useActionState, useOptimistic và khả năng phục hồi của Server Action với kiến trúc cấp độ sản phẩm và ví dụ mã.
Đọc tiếp
Hướng dẫn toàn diện về quản lý trạng thái React năm 2026: so sánh React 19 actions, trạng thái máy chủ TanStack Query, Zustand, Jotai và Signals.
Đọc tiếp