JSX

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:

React JSXJSX
// 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:

React JSXJSX
// 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:

React JSXJSX
// 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:

JavaScriptJAVASCRIPT
// 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:

React JSXJSX
// SALAH: dua elemen tanpa pembungkus
return (
  <h1>Judul</h1>
  <p>Deskripsi</p>
)
React JSXJSX
// 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:

React JSXJSX
// src/App.jsx
import { Fragment } from 'react'

return (
  <Fragment>
    <h1>Judul</h1>
    <p>Deskripsi</p>
  </Fragment>
)

Atau gunakan sintaks singkatnya yang lebih umum dipakai:

React JSXJSX
// 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:

React JSXJSX
// SALAH: tag tidak ditutup
<img src="/foto.jpg">
<input type="text">
<br>
React JSXJSX
// 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:

  • class di HTML menjadi className di JSX (karena class adalah reserved keyword JavaScript)
  • for di HTML menjadi htmlFor di JSX (karena for juga reserved keyword)
React JSXJSX
// HTML biasa
<div class="kartu aktif">
  <label for="nama-input">Nama:</label>
  <input id="nama-input" type="text">
</div>
React JSXJSX
// 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 { }.

React JSXJSX
// 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:

React JSXJSX
// 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.

React JSXJSX
// 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:

React JSXJSX
// 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:

React JSXJSX
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:

  1. Buka src/App.jsx dan ubah konten yang dikembalikan menjadi sebuah <section> dengan header yang menampilkan nama kamu dan tanggal hari ini menggunakan ekspresi { }.

  2. Buat sebuah variabel statusSistem dengan nilai string 'aktif' atau 'nonaktif'. Gunakan operator ternary di dalam JSX untuk menampilkan teks berbeda berdasarkan nilai variabel tersebut.

  3. 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.

Referensi

  1. 1 Mengenal JSX: Bahasa Mark-up di React: BuildWithAngga
  2. 2 Introducing the New JSX Transform: React Blog
  3. 3 Writing Markup with JSX: React Documentation