Selamat datang di episode keempat series React Lanjutan. Di tiga episode sebelumnya kamu sudah belajar React Router untuk navigasi, Context API untuk state global, dan custom hooks untuk logika yang bisa dipakai ulang. Aplikasimu sekarang sudah fungsional. Pertanyaannya, apakah dia juga cepat?
Topik performa ini sengaja ditaruh di titik ini, bukan di awal. Alasannya sederhana. Optimasi yang dilakukan sebelum kamu paham cara kerja React biasanya malah merusak kode. Kamu menempel useMemo di mana-mana, membungkus semua komponen dengan React.memo, lalu bingung kenapa aplikasinya tidak terasa lebih cepat tapi kodenya jadi susah dibaca. Episode ini akan meluruskan cara berpikirnya dulu, baru tekniknya.
Mitos pertama, optimasi artinya menempel memo di mana-mana
Ini persepsi salah yang paling umum. Banyak tutorial mengajarkan useMemo dan useCallback seolah itu vitamin yang harus diminum tiap komponen. Kenyataannya, setiap memo itu sendiri punya biaya. React harus menyimpan nilai lama, membandingkan dependensi di setiap render, dan mengelola cache. Kalau komputasi yang di-memo itu sepele, misalnya penjumlahan dua angka, maka biaya memoisasinya justru lebih mahal daripada menghitung ulangnya.
// Jangan lakukan ini. Biaya memo lebih mahal dari penjumlahan.
const total = useMemo(() => harga + pajak, [harga, pajak]);
// Cukup tulis begini.
const total = harga + pajak;
Prinsip yang benar adalah ukur dulu, optimasi kemudian. React tidak melambat karena render itu sendiri. Render itu normal dan murah untuk komponen kecil. React melambat ketika ada render yang tidak perlu pada komponen yang mahal, atau ketika komputasi berat diulang tanpa alasan.
Mitos kedua, React Compiler membuat ilmu ini tidak perlu dipelajari
React 19 membawa React Compiler yang otomatis memoisasi komponen saat build. Sebagian orang menyimpulkan kalau begitu useMemo dan kawan-kawan sudah usang dan tidak perlu dipahami. Ini keliru di dua titik. Pertama, compiler harus diaktifkan di konfigurasi build, dia tidak otomatis jalan cuma karena kamu upgrade React. Kedua, dan ini yang lebih penting, compiler hanya mengotomatiskan mekanismenya, bukan pemahamannya. Ketika aplikasimu tetap lambat padahal compiler sudah aktif, kamu tetap butuh paham kenapa sebuah komponen render ulang dan props apa yang tidak stabil. Ilmu di episode ini justru jadi bekal untuk debugging di era compiler.
Berhenti dan tebak dulu! Komponen Anak dibungkus React.memo. Induknya render ulang karena state lain berubah, tapi props yang dikirim ke Anak tidak berubah nilainya. Apakah Anak ikut render ulang?
const Anak = React.memo(function Anak({ nama }) {
console.log("Anak render");
return <p>Halo {nama}</p>;
});
function Induk() {
const [hitung, setHitung] = useState(0);
return (
<>
<button onClick={() => setHitung(hitung + 1)}>Klik {hitung}</button>
<Anak nama="Budi" />
</>
);
}
Cara berpikir yang benar, ukur dulu baru sentuh
Analoginya seperti dokter. Dokter yang baik tidak langsung memberi obat sebelum memeriksa pasien. Alat pemeriksanya ada dua. Pertama, React DevTools Profiler, ekstensi browser yang menunjukkan komponen mana yang render, kenapa dia render, dan berapa lama waktunya. Kedua, React Scan, tool yang memvisualkan render ulang secara real time saat kamu memakai aplikasi. Alurnya selalu sama. Identifikasi komponen lambat, catat baseline, analisis penyebabnya, optimasi, lalu verifikasi hasilnya. Kalau setelah dioptimasi tidak ada perbedaan yang terukur, kembalikan kodenya ke versi yang paling mudah dibaca.
Tiga senjata memo dan kapan masing-masing dipakai
Bayangkan dapur restoran. React.memo itu seperti pelayan yang tidak mengantar ulang hidangan kalau pesanannya sama persis. useMemo itu seperti koki yang menyimpan hasil masakan yang lama dibuatnya, jadi tidak masak ulang kalau bahannya sama. useCallback itu seperti memastikan nomor telepon kurir tidak berubah-ubah, supaya pelayan tidak bingung.
React.memo dipakai untuk komponen mahal yang sering menerima props yang sama. Komponen mahal artinya render-nya berat, misalnya daftar panjang atau chart. useMemo dipakai untuk komputasi yang benar-benar berat, misalnya filter 10.000 produk, atau untuk menjaga kestabilan referensi object yang dikirim sebagai props ke komponen yang di-memo. useCallback dipakai untuk fungsi yang dikirim ke komponen yang di-memo, atau yang dipakai sebagai dependensi useEffect. Di luar tiga skenario itu, jangan dipakai.
Berhenti dan tebak dulu! Kode ini bermaksud memoisasi daftar yang difilter. Ada yang salah. Apa itu?
function DaftarProduk({ produk }) {
const [cari, setCari] = useState("");
const hasil = useMemo(() => {
return produk.filter((p) => p.nama.includes(cari));
}, [produk]);
// ...
}
Optimasi di luar memo, code splitting dan virtualisasi
Tidak semua masalah performa soal render ulang. Kadang masalahnya adalah bundle yang terlalu besar sehingga halaman pertama lama dibuka. Solusinya code splitting dengan React.lazy dan Suspense. Halaman atau fitur yang jarang dibuka tidak perlu diunduh di awal. Masalah lain adalah daftar yang sangat panjang, misalnya 1.000 baris tabel. Solusinya virtualisasi, hanya baris yang terlihat di layar yang benar-benar di-render, dengan library seperti react-window. Aturan praktisnya, daftar di atas 100 item layak dipertimbangkan untuk divirtualisasi, di bawah 50 item biasanya tidak perlu.
Kuis cepat: Kapan useMemo layak dipakai?
Kapan memo manual masih dibutuhkan di era compiler
React Compiler memang mengotomatiskan sebagian besar memo, tapi ada tiga situasi di mana pemahaman dan intervensi manual tetap perlu. Pertama, kode yang tidak bisa dianalisis compiler secara statis, misalnya pola yang terlalu dinamis atau library pihak ketiga yang bermain dengan referensi. Kedua, kasus di mana yang kamu butuhkan bukan sekadar performa tapi jaminan kebenaran, misalnya dependensi useEffect yang harus stabil supaya efek tidak jalan berulang. Ketiga, codebase lama yang belum mengaktifkan compiler.
Yang lebih penting dari ketiganya adalah urutan berpikir yang tidak berubah. Compiler menggantikan tanganmu menempel memo, tapi tidak menggantikan otakmu memutuskan arsitektur. State yang ditaruh terlalu tinggi tetap menyebabkan render ulang yang luas, compiler atau tidak. Component yang raksasa tetap sulit dioptimasi. Jadi bekal episode ini bukan soal hafal API, tapi soal cara membaca alur render React. Itu skill yang tidak kedaluwarsa.
Latihan dan langkah berikutnya
Latihan minggu ini ada dua. Pertama, install React DevTools di browser, buka salah satu proyek React-mu, rekam sesi profiling saat kamu berinteraksi dengan aplikasi, lalu catat tiga komponen yang paling sering render ulang. Kedua, pilih SATU yang memang mahal, terapkan React.memo plus stabilkan props-nya dengan useMemo atau useCallback, lalu ukur lagi dan bandingkan waktunya. Jangan optimasi semuanya, cukup satu, tapi dengan data sebelum dan sesudah.
Di episode berikutnya kita masuk ke form lanjutan dan validasi. Ini topik yang terlihat sepele tapi diam-diam jadi sumber bug terbanyak di aplikasi React. Kamu akan belajar kenapa form dengan belasan input tidak boleh dikelola dengan useState satu per satu, dan kenapa library seperti React Hook Form bisa jauh lebih cepat. Siapkan satu form yang pernah bikin kamu pusing, karena kita akan bedah ulang dari nol.
Diskusi & Komentar 0
Punya tanggapan, pertanyaan, atau tips seputar tutorial ini? Tulis komentar kamu di bawah!
Jadilah yang pertama membuka obrolan dan berbagi pandangan seputar tutorial resep kode ini.
Tulis Komentar
Komentar menggunakan akun Google. Harap berkomentar dengan santun dan berbobot.