Fondasi React

BAB 4: Render HTML dengan React

Bagaimana React merender elemen ke browser, apa itu virtual DOM, dan perbedaan merender elemen langsung vs lewat komponen.

Di bab sebelumnya, kita menelusuri main.jsx dan menemukan baris createRoot(document.getElementById('root')).render(...) yang menjadi titik awal semua yang tampil di browser. Kita menyebutnya tapi tidak terlalu mendalaminya, saat itu konteksnya belum perlu. Sekarang saatnya kita bedah dengan lebih serius.

Memahami bagaimana React merender ke DOM bukan sekadar pengetahuan akademis. Ini fondasi yang menjelaskan mengapa komponen ditulis dengan cara tertentu, mengapa perubahan state memicu tampilan berubah, dan bagaimana React bisa melakukan itu semua dengan sangat efisien.

Wadah di index.html

Buka index.html di root project daftar-tugas. File ini terlihat hampir kosong, dan memang demikian yang diharapkan:

HTMLHTML
<!-- index.html -->
<!doctype html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Daftar Tugas</title>
  </head>
  <body>
    <div id="root"></div>
    <script type="module" src="/src/main.jsx"></script>
  </body>
</html>

<div id="root"> adalah satu-satunya elemen HTML yang benar-benar penting di sini. React akan mengambil div ini dan menjadikannya container: semua yang kamu tulis di komponen React akan dimasukkan ke dalamnya saat runtime.

Div itu tidak harus bernama "root". Kamu bisa menamainya app, container, atau apapun. Tidak harus berupa <div> juga, bisa <main>, <section>, atau elemen lain. Yang penting, ID yang kamu tulis di HTML harus cocok dengan ID yang kamu minta di main.jsx.

Dalam proyek yang mengintegrasikan React ke halaman web yang sudah ada (bukan aplikasi React penuh), kamu bahkan bisa punya beberapa container sekaligus, satu untuk navigasi, satu untuk komentar, satu untuk widget lainnya. Masing-masing punya root React sendiri.

createRoot dan root.render

Di main.jsx, ada dua langkah yang terjadi secara berurutan:

React JSXJSX
// src/main.jsx
import { createRoot } from 'react-dom/client'
import App from './App.jsx'

createRoot(document.getElementById('root')).render(
  <App />
)

Langkah pertama: createRoot(document.getElementById('root')) mengambil elemen DOM dengan ID root dan menyerahkannya ke React. Setelah ini, React "mengambil kendali" atas div tersebut, isi div itu sepenuhnya dikelola React, bukan kamu.

Langkah kedua: .render(<App />) memberitahu React apa yang harus ditampilkan di dalam container tadi. Argumennya adalah komponen React, dalam kasus ini App, komponen root yang menjadi induk dari seluruh aplikasi.

Dua langkah ini bisa juga ditulis secara terpisah untuk lebih eksplisit:

React JSXJSX
// src/main.jsx: versi lebih eksplisit
import { createRoot } from 'react-dom/client'
import App from './App.jsx'

const containerElement = document.getElementById('root')
const reactRoot = createRoot(containerElement)

reactRoot.render(<App />)

Hasilnya identik, ini hanya soal preferensi gaya penulisan. Dalam project nyata, bentuk yang lebih ringkas (rantai langsung) lebih umum dijumpai.

Virtual DOM: Mengapa React Lebih Efisien

Kamu mungkin bertanya-tanya: jika React merender ke DOM seperti JavaScript biasa, apa bedanya dengan memanipulasi DOM secara langsung menggunakan document.getElementById atau innerHTML?

Jawabannya ada di Virtual DOM: konsep inti yang membuat React bekerja dengan cara berbeda.

Manipulasi DOM langsung itu mahal secara komputasi. Setiap kali kamu mengubah satu elemen, browser perlu menghitung ulang layout, menggambar ulang piksel, dan kadang mengatur ulang seluruh halaman. Ini tidak masalah untuk perubahan sesekali, tapi di aplikasi web modern yang bisa memiliki ratusan pembaruan per detik, ini menjadi bottleneck nyata.

React memperkenalkan lapisan di antara kode kamu dan DOM browser:

CodeTEXT
Kode React (JSX)  →  Virtual DOM (di memori)  →  DOM nyata (di browser)
                         |
                   React membandingkan
                   versi lama vs baru
                   (reconciliation)
                         |
                   Hanya perbedaan yang
                   dikirim ke DOM nyata
CodeIMAGE
A clean technical diagram showing React's Virtual DOM process in three stages. Left box labeled "Kode React (JSX)" with JSX angle bracket symbols inside, blue background. Center box labeled "Virtual DOM" with a tree structure of nodes inside, cyan background. Right box labeled "DOM Nyata" with HTML-like elements inside, gray background. Arrows between boxes: first arrow labeled "React membangun", second arrow labeled "hanya perubahan (diff)". Below center box, a smaller callout box labeled "Reconciliation: bandingkan versi lama vs baru". White background, flat design, clean technical diagram style, sans-serif font, 16:9 aspect ratio. All text labels in Indonesian.

Setiap kali ada perubahan (state berubah, props baru masuk), React tidak langsung menyentuh DOM. React terlebih dahulu membangun representasi Virtual DOM yang baru di memori, membandingkannya dengan Virtual DOM yang lama, menemukan apa yang berubah, lalu hanya mengirim perbedaan itu ke DOM nyata. Proses ini disebut reconciliation.

Hasilnya: browser hanya bekerja untuk perubahan yang benar-benar diperlukan, bukan me-render ulang seluruh halaman.

Merender Langsung vs Lewat Komponen

Ada dua cara memberikan konten ke root.render(). Cara pertama: merender elemen JSX langsung tanpa komponen terpisah.

React JSXJSX
// src/main.jsx: render elemen langsung
import { createRoot } from 'react-dom/client'

const reactRoot = createRoot(document.getElementById('root'))

reactRoot.render(
  <div>
    <h1>Daftar Tugas</h1>
    <p>Kelola aktivitas harianmu di sini.</p>
  </div>
)

Ini valid secara teknis dan berguna untuk eksperimen cepat atau debugging. Tapi untuk aplikasi sungguhan, cara ini tidak praktis, semua kode aplikasimu akan berantakan di main.jsx.

Cara kedua (yang sudah kita gunakan sejak awal) adalah merender komponen:

React JSXJSX
// src/main.jsx: render lewat komponen (cara standar)
import { createRoot } from 'react-dom/client'
import App from './App.jsx'

createRoot(document.getElementById('root')).render(<App />)

App di sini bisa memiliki komponen-komponen lain di dalamnya, yang masing-masing juga bisa punya komponen-komponen lain, membentuk pohon komponen. main.jsx tetap bersih, ia hanya tahu tentang satu komponen: App.

Anggap main.jsx sebagai pintu masuk gedung, bukan isi gedungnya. Ia hanya bertugas membuka pintu dan menyambut tamu pertama (App). Semua ruangan dan furnitur di dalam gedung adalah urusan App.jsx dan komponen-komponen turunannya.

Memahami StrictMode

Di main.jsx default Vite, ada StrictMode yang membungkus App:

React JSXJSX
import { StrictMode } from 'react'
import { createRoot } from 'react-dom/client'
import App from './App.jsx'

createRoot(document.getElementById('root')).render(
  <StrictMode>
    <App />
  </StrictMode>
)

StrictMode bukan komponen biasa. Ia tidak menghasilkan elemen HTML apapun di browser, kamu tidak akan menemukannya jika inspect DOM. Tugasnya eksklusif untuk development: membantu menemukan potensi masalah lebih awal.

Salah satu hal yang dilakukan StrictMode adalah menjalankan fungsi komponen dua kali di development mode. Ini sengaja, untuk memastikan komponen kamu tidak punya efek samping yang tidak diharapkan saat React menjalankannya ulang (sesuatu yang bisa terjadi di Concurrent Mode). Di production, perilaku ganda ini tidak terjadi.

Jika kamu melihat sesuatu seperti console.log yang muncul dua kali di development, itu bukan bug, itu StrictMode bekerja. Jangan hapus StrictMode hanya karena log muncul duplikat. Periksa apakah ada efek samping di komponen kamu yang seharusnya tidak dijalankan dua kali.

Latihan

Coba dua eksperimen berikut untuk membangun intuisi tentang render:

  1. Di main.jsx, ganti <App /> dengan elemen JSX langsung, misalnya <h1>Hello dari main.jsx</h1>. Lihat apa yang tampil di browser. Kemudian kembalikan ke <App />.

  2. Di index.html, ubah ID dari root menjadi aplikasi-tugas. Kemudian sesuaikan juga document.getElementById('root') di main.jsx menjadi document.getElementById('aplikasi-tugas'). Pastikan aplikasi tetap berjalan normal, ini membuktikan bahwa nama ID bisa apapun selama konsisten.

  3. Tantangan: Buat root kedua. Di index.html, tambahkan <div id="info-bar"></div> di luar <div id="root">. Di main.jsx, buat root kedua yang merender <p>Versi 1.0.0</p> ke dalam info-bar. Perhatikan bagaimana dua root React bisa hidup berdampingan di satu halaman.

Penutup

React mengambil sebuah div kosong dan mengisinya dengan seluruh aplikasi, proses yang terlihat sederhana tapi ditopang oleh mekanisme Virtual DOM yang cerdas. Setiap perubahan yang nanti kita buat (baik lewat state maupun props) akan melalui proses yang sama: React membangun Virtual DOM baru, membandingkannya dengan yang lama, dan hanya memperbarui bagian DOM yang benar-benar berubah.

Yang kita tulis di dalam render() bukan HTML biasa, ada lapisan abstraksi bernama JSX yang bekerja di antaranya. Saat ini kita menulisnya tanpa benar-benar tahu kenapa <div> di JSX tidak sepenuhnya sama dengan <div> di HTML. Perbedaan itu kecil tapi penting, dan itulah yang akan kita kulik tuntas di bab berikutnya.

Referensi

  1. 1 createRoot: Referensi API React DOM
  2. 2 Declarative vs Imperative UI: Dokumentasi Resmi React
  3. 3 Virtual DOM dan Internal: Dokumentasi React (Bahasa Indonesia)