BAB 7: Pengenalan JSX
Apa itu JSX, mengapa React menggunakannya, dan bagaimana JSX dikompilasi menjadi pemanggilan fungsi JavaScript biasa.
Di penutup bab sebelumnya, saya menyebut bahwa ES6 akan segera terasa nyata saat kita mulai menulis markup di React. Nah, momen itu ada di bab ini. Kita masuk ke JSX, salah satu hal pertama yang membuat developer baru React bertanya-tanya: "Ini HTML atau JavaScript?"
Jawabannya: keduanya. Dan itu bukan bug, itu desain yang disengaja.
Apa Itu JSX
JSX adalah singkatan dari JavaScript XML. Ia adalah ekstensi sintaks yang memungkinkan kita menulis markup seperti HTML langsung di dalam kode JavaScript. Bukan string, bukan template, melainkan sintaks yang dimengerti oleh compiler dan ditransformasi menjadi JavaScript biasa sebelum dijalankan di browser.
Perhatikan baris kode ini:
// src/App.jsx
const judulHalaman = <h1>Selamat datang di aplikasi kita!</h1>
Secara sekilas ini terlihat seperti HTML di-assign ke variabel JavaScript. Dan itulah yang dilakukan JSX, ia memperbolehkan kita mencampur markup dengan logika di satu tempat yang sama.
Tanpa JSX, menulis elemen yang sama membutuhkan cara yang jauh lebih verbose:
// tanpa JSX: React murni
const judulHalaman = React.createElement('h1', null, 'Selamat datang di aplikasi kita!')
React.createElement menerima tiga argumen: tipe elemen, props (kita bahas di Bab 13), dan konten anak. Untuk elemen sederhana satu baris, ini masih terbaca. Tapi bayangkan saat kita punya hierarki markup yang dalam, puluhan baris createElement bersarang yang harus dilacak secara mental. JSX hadir untuk membuat pekerjaan itu manusiawi.
Bagaimana JSX Dikompilasi
JSX bukan bagian dari JavaScript standar. Browser tidak memahami sintaks JSX secara native. Yang terjadi adalah: sebelum kode kita dijalankan, sebuah compiler (di proyek Vite kita, ini adalah plugin @vitejs/plugin-react yang menggunakan Babel di balik layar) mentransformasi setiap ekspresi JSX menjadi pemanggilan fungsi JavaScript biasa.
Sejak React 17, transformasi tersebut menggunakan fungsi dari paket react/jsx-runtime alih-alih React.createElement. Artinya, kamu tidak perlu lagi menulis import React from 'react' di setiap file yang menggunakan JSX, compiler secara otomatis menyuntikkan import yang diperlukan.
Contoh sederhana:
// yang kita tulis
const kartu = (
<div className="kartu">
<h2>Daftar Tugas</h2>
<p>Kamu punya 3 tugas hari ini</p>
</div>
)
Setelah dikompilasi, kira-kira jadi seperti ini:
// hasil kompilasi: tidak perlu ditulis manual
import { jsx as _jsx, jsxs as _jsxs } from 'react/jsx-runtime'
const kartu = _jsxs('div', {
className: 'kartu',
children: [
_jsx('h2', { children: 'Daftar Tugas' }),
_jsx('p', { children: 'Kamu punya 3 tugas hari ini' })
]
})
Kamu tidak perlu memahami output kompilasi ini secara mendalam, compiler mengurusnya secara transparan. Tapi mengetahui bahwa JSX "hanyalah" syntactic sugar di atas pemanggilan fungsi biasa akan membantu saat kamu nanti menemukan error yang merujuk ke proses kompilasi.
Aturan Dasar JSX
JSX terlihat seperti HTML, tapi ia mengikuti aturan XML yang lebih ketat. Beberapa perbedaan penting perlu dipahami dari awal agar kamu tidak kehabisan waktu debugging hal yang sebenarnya sederhana.
Satu Elemen Root
Setiap blok JSX harus dibungkus dalam satu elemen induk. Menulis dua elemen bersebelahan tanpa pembungkus akan menghasilkan error:
// SALAH: dua elemen tanpa pembungkus
return (
<h1>Judul</h1>
<p>Deskripsi</p>
)
// BENAR: dibungkus dalam satu div
return (
<div>
<h1>Judul</h1>
<p>Deskripsi</p>
</div>
)
Jika tidak ingin menambahkan div yang tidak perlu ke dalam DOM, gunakan Fragment: pembungkus transparan yang tidak menghasilkan elemen DOM:
// src/App.jsx
import { Fragment } from 'react'
return (
<Fragment>
<h1>Judul</h1>
<p>Deskripsi</p>
</Fragment>
)
Atau gunakan sintaks singkatnya yang lebih umum dipakai:
// src/App.jsx
return (
<>
<h1>Judul</h1>
<p>Deskripsi</p>
</>
)
<>...</> adalah shorthand Fragment yang bisa kamu temukan hampir di setiap proyek React modern. Ia tidak menambahkan node apapun ke DOM, tapi memenuhi persyaratan satu elemen root.
Semua Tag Harus Ditutup
HTML punya elemen yang tidak butuh tag penutup: <br>, <img>, <input>. Di JSX, semua tag harus ditutup, baik dengan tag penutup eksplisit maupun self-closing:
// SALAH: tag tidak ditutup
<img src="/foto.jpg">
<input type="text">
<br>
// BENAR: self-closing
<img src="/foto.jpg" />
<input type="text" />
<br />
camelCase untuk Atribut
Karena JSX dikompilasi menjadi JavaScript, nama atribut mengikuti konvensi camelCase JavaScript, bukan nama atribut HTML yang menggunakan lowercase atau hyphen.
Dua yang paling sering ditemui:
classdi HTML menjadiclassNamedi JSX (karenaclassadalah reserved keyword JavaScript)fordi HTML menjadihtmlFordi JSX (karenaforjuga reserved keyword)
// HTML biasa
<div class="kartu aktif">
<label for="nama-input">Nama:</label>
<input id="nama-input" type="text">
</div>
// JSX yang benar
<div className="kartu aktif">
<label htmlFor="nama-input">Nama:</label>
<input id="nama-input" type="text" />
</div>
Atribut event handler juga menggunakan camelCase: onclick menjadi onClick, onchange menjadi onChange, onsubmit menjadi onSubmit, dan seterusnya. Kita akan bahas event handler secara mendalam di Bab 16.
Ekspresi JavaScript di JSX
Kekuatan JSX bukan hanya kemampuan menulis markup, tapi kemampuan menyisipkan ekspresi JavaScript langsung di dalam markup menggunakan kurung kurawal { }.
// src/App.jsx
const namaPengguna = 'Rania'
const totalTugas = 5
return (
<div>
<h1>Halo, {namaPengguna}!</h1>
<p>Kamu punya {totalTugas} tugas yang belum selesai.</p>
<p>Semua tugas: {totalTugas * 2} (termasuk yang sudah selesai)</p>
</div>
)
Apapun yang valid sebagai ekspresi JavaScript bisa ditempatkan di dalam { }: variabel, kalkulasi aritmatika, pemanggilan fungsi, method array, operator ternary. Yang tidak bisa adalah statement seperti if, for, atau while, karena statement tidak menghasilkan nilai.
Destructuring dan spread yang kita pelajari di Bab 6 langsung berguna di sini. Saat kita nanti mengambil data dari API dan merender hasilnya, pola seperti ini akan terasa sangat natural:
// src/App.jsx
const tugas = { judul: 'Belajar JSX', prioritas: 'tinggi', selesai: false }
const { judul, prioritas, selesai } = tugas
return (
<div className={`kartu kartu--${prioritas}`}>
<h3>{judul}</h3>
<span>{selesai ? 'Selesai' : 'Belum selesai'}</span>
</div>
)
JSX Adalah Ekspresi
Satu hal yang sering diabaikan pemula: JSX adalah ekspresi JavaScript, ia menghasilkan nilai. Artinya, kita bisa menyimpan JSX ke variabel, mengembalikannya dari fungsi, meneruskannya sebagai argumen, bahkan menempatkannya di dalam { } dari JSX lain.
// src/App.jsx
const badgePrioritas = (
<span className="badge badge--tinggi">Prioritas Tinggi</span>
)
const kartuTugas = (
<div className="kartu">
<h3>Revisi desain landing page</h3>
{badgePrioritas}
</div>
)
Kemampuan ini adalah fondasi dari sistem komponen React. Sebuah komponen pada dasarnya adalah fungsi yang menerima data dan mengembalikan JSX, yang kemudian bisa disisipkan ke JSX lain seperti elemen HTML biasa. Kita akan membangun di atas konsep ini mulai Bab 11.
JSX Multi-Baris
Untuk markup yang lebih panjang, bungkus JSX dalam kurung ( ) agar bisa ditulis multi-baris tanpa masalah:
// src/App.jsx
const tampilan = (
<section className="daftar-tugas">
<header>
<h1>Tugas Hari Ini</h1>
<p>Minggu, 15 Maret 2026</p>
</header>
<ul>
<li className="tugas selesai">Riset teknologi baru</li>
<li className="tugas">Tulis dokumentasi API</li>
<li className="tugas">Review pull request tim</li>
</ul>
</section>
)
Kurung di sini bukan bagian dari JSX, ia hanyalah sintaks JavaScript biasa yang membiarkan ekspresi multi-baris tanpa membingungkan parser. Tanpa kurung, kode yang kembali ke baris baru setelah return akan menghasilkan undefined karena JavaScript secara otomatis menyisipkan titik koma di akhir baris return.
Jika kamu menulis return tanpa kurung dan JSX-nya ada di baris berikutnya, komponen akan mengembalikan undefined secara diam-diam. Selalu gunakan kurung untuk JSX multi-baris yang dikembalikan dari fungsi.
Komentar di JSX
Komentar JavaScript biasa (// dan /* */) tidak bisa diletakkan langsung di dalam JSX. Untuk menulis komentar di dalam markup JSX, gunakan ekspresi { } yang berisi komentar JavaScript:
return (
<div>
{/* ini adalah komentar di JSX */}
<h1>Judul</h1>
{/*
komentar multi-baris juga bisa
tapi harus tetap di dalam kurung kurawal
*/}
<p>Deskripsi</p>
</div>
)
Latihan
Dengan pemahaman JSX yang baru didapat, coba kerjakan latihan berikut pada proyek daftar-tugas:
-
Buka
src/App.jsxdan ubah konten yang dikembalikan menjadi sebuah<section>dengan header yang menampilkan nama kamu dan tanggal hari ini menggunakan ekspresi{ }. -
Buat sebuah variabel
statusSistemdengan nilai string'aktif'atau'nonaktif'. Gunakan operator ternary di dalam JSX untuk menampilkan teks berbeda berdasarkan nilai variabel tersebut. -
Coba sengaja hilangkan tag penutup dari salah satu elemen, lalu perhatikan pesan error yang muncul di terminal dev server. Biasakan diri membaca error message kompilasi, itu skill yang sangat berguna.
Penutup
JSX bukan keajaiban, ia adalah syntactic sugar yang compiler ubah menjadi pemanggilan fungsi JavaScript biasa. Tapi sugar yang baik mengubah pengalaman coding secara fundamental, dan JSX memang melakukan itu: ia memungkinkan kita berpikir dalam unit visual (markup) sekaligus logika (JavaScript) tanpa harus berpindah konteks mental.
Aturan-aturan yang perlu diingat tidak banyak: satu elemen root, semua tag ditutup, atribut dalam camelCase, dan ekspresi JavaScript di dalam kurung kurawal. Seiring latihan, aturan-aturan ini akan terasa seperti naluri, bukan hafalan.
Sejauh ini kita menggunakan JSX untuk menampilkan nilai statis. Tapi nilai sebenarnya JSX baru terasa saat kita mulai menyisipkan variabel dan ekspresi yang lebih kompleks, kalkulasi, kondisi, hasil transformasi array. Di bab berikutnya, kita akan mengeksplorasi kemampuan itu lebih jauh: cara menyisipkan berbagai jenis ekspresi JavaScript ke dalam JSX dan batas-batas apa yang berlaku.