Komponen dan Props

BAB 15: Props Children

Gunakan props.children untuk membuat komponen yang bisa membungkus konten arbitrer, fondasi pola komposisi di React.

Di bab sebelumnya, kita mempersingkat cara mengakses props dengan destructuring, alih-alih menulis props.judul, props.status, props.nomor, kita langsung mengekstrak ketiganya di parameter fungsi. Tapi semua props yang kita kirim sejauh ini bersifat eksplisit: nama propnya kita tentukan, nilainya kita kirim secara langsung.

Ada pola berbeda yang sering muncul ketika membangun antarmuka: kita ingin membuat komponen yang bertindak sebagai wadah. Komponen yang tidak peduli apa yang ada di dalamnya (apakah itu teks, gambar, form, atau komponen lain) selama ia bisa membungkus dan menampilkan kontennya dengan konsisten. Di sinilah props.children bekerja.

Apa Itu props.children

Ketika kamu menulis JSX seperti ini:

React JSXJSX
<Panel>
  <p>Konten yang ada di dalam komponen Panel.</p>
</Panel>

React secara otomatis mengemas semua konten di antara tag pembuka <Panel> dan tag penutup </Panel> ke dalam sebuah props khusus bernama children. Komponen Panel bisa mengaksesnya melalui props.children, atau lewat destructuring seperti yang sudah kita pelajari.

Ini berbeda dari props biasa. children tidak perlu kamu kirim secara eksplisit dengan atribut children="...", cukup letakkan kontennya di antara tag buka dan tutup komponen.

Komponen Pembungkus Pertama

Mari kita buat komponen Panel yang sederhana, komponen yang membungkus konten dengan border dan padding yang konsisten, sehingga kita tidak perlu mengulang class CSS yang sama di setiap halaman.

React JSXJSX
// src/components/Panel.jsx
function Panel({ children }) {
  return (
    <div className="panel">
      {children}
    </div>
  )
}

export default Panel

Sekarang di App.jsx, kita bisa menggunakan Panel sebagai wadah:

React JSXJSX
// src/App.jsx
import Panel from './components/Panel'
import KartuTugas from './components/KartuTugas'

function App() {
  return (
    <div>
      <Panel>
        <h2>Tugas Aktif</h2>
        <KartuTugas judul="Buat halaman login" status="Aktif" nomor={1} />
        <KartuTugas judul="Setup database" status="Aktif" nomor={2} />
      </Panel>

      <Panel>
        <h2>Tugas Selesai</h2>
        <KartuTugas judul="Init project" status="Selesai" nomor={0} />
      </Panel>
    </div>
  )
}

Perhatikan: dua Panel yang berbeda bisa menampung konten yang sama sekali berbeda. Yang pertama berisi heading dan dua KartuTugas, yang kedua berisi heading dan satu KartuTugas. Komponen Panel tidak tahu dan tidak perlu tahu apa yang ada di dalamnya, ia hanya menyediakan pembungkus yang konsisten.

Destructuring { children } di parameter fungsi bekerja persis sama seperti destructuring props lainnya. Kamu juga bisa menulisnya props.children jika menerima props sebagai objek biasa, hasilnya identik.

Menggabungkan children dengan Props Lain

children adalah props biasa, yang berarti ia bisa dikombinasikan dengan props lain seperti biasa. Ini membuka banyak kemungkinan: komponen Panel bisa punya judul sendiri, warna aksen, atau varian tampilan, sementara konten di dalamnya tetap fleksibel.

React JSXJSX
// src/components/Panel.jsx
function Panel({ judul, children }) {
  return (
    <div className="panel">
      {judul && <h3 className="panel-judul">{judul}</h3>}
      <div className="panel-konten">
        {children}
      </div>
    </div>
  )
}

export default Panel

Penggunaan:

React JSXJSX
// src/App.jsx
<Panel judul="Tugas Aktif">
  <KartuTugas judul="Buat halaman login" status="Aktif" nomor={1} />
  <KartuTugas judul="Setup database" status="Aktif" nomor={2} />
</Panel>

<Panel>
  <p>Panel tanpa judul, prop judul tidak dikirim, jadi bagian header tidak dirender.</p>
</Panel>

Kondisi {judul && <h3>...</h3>} memastikan bagian header hanya dirender jika props judul dikirim. Panel tanpa judul tetap berfungsi dengan baik karena judul bersifat opsional.

children Bisa Apa Saja

Nilai dari props.children bisa berupa apa pun yang valid di JSX:

  • String: <Panel>Teks biasa</Panel>
  • Elemen HTML: <Panel><p>Paragraf</p></Panel>
  • Komponen lain: <Panel><KartuTugas ... /></Panel>
  • Beberapa elemen sekaligus: React akan membungkusnya sebagai array
  • Tidak ada, jika tidak ada konten antara tag buka dan tutup, children bernilai undefined

Justru karena fleksibilitas ini, props.children menjadi fondasi dari pola komposisi komponen di React. Alih-alih mewariskan perilaku lewat inheritance seperti di bahasa OOP, React mendorong kita membangun komponen kompleks dengan merangkai komponen-komponen sederhana.

Pola Layout dengan children

Pola yang sangat umum di aplikasi React nyata adalah membuat komponen layout yang menentukan struktur halaman, sementara konten halaman dikirim sebagai children.

React JSXJSX
// src/components/HalamanLayout.jsx
function HalamanLayout({ judul, children }) {
  return (
    <main className="halaman">
      <header className="halaman-header">
        <h1>{judul}</h1>
      </header>
      <section className="halaman-konten">
        {children}
      </section>
      <footer className="halaman-footer">
        <small>Sistem Manajemen Tugas &copy; 2026</small>
      </footer>
    </main>
  )
}

export default HalamanLayout
React JSXJSX
// src/App.jsx
import HalamanLayout from './components/HalamanLayout'
import Panel from './components/Panel'
import KartuTugas from './components/KartuTugas'

function App() {
  return (
    <HalamanLayout judul="Dashboard">
      <Panel judul="Tugas Aktif">
        <KartuTugas judul="Buat halaman login" status="Aktif" nomor={1} />
      </Panel>
      <Panel judul="Tugas Selesai">
        <KartuTugas judul="Init project" status="Selesai" nomor={0} />
      </Panel>
    </HalamanLayout>
  )
}

Sekarang HalamanLayout bertanggung jawab atas struktur keseluruhan halaman (header, konten, footer) sementara konten spesifiknya dikirim dari App. Jika suatu saat kita ingin mengubah tampilan header atau footer, cukup ubah di satu tempat.

Pola ini adalah cikal bakal dari apa yang disebut "layout component" di framework seperti Next.js. Konsepnya sama, komponen yang mendefinisikan kerangka, sementara konten halaman dikirim sebagai children.

Latihan

Kembangkan aplikasi manajemen tugas yang sudah kita bangun:

  1. Buat komponen Kartu yang lebih generik dari KartuTugas, komponen yang menerima props judul, aksen (warna border kiri, misal "biru" atau "merah"), dan children untuk konten di dalam kartu. Gunakan Kartu sebagai dasar komponen KartuTugas yang sudah ada.

  2. Buat komponen GrupTugas yang menerima props nama dan children. Di dalamnya tampilkan nama grup sebagai heading dan children di bawahnya. Gunakan GrupTugas di App.jsx untuk mengelompokkan tugas-tugas aktif dan selesai.

  3. Apa yang terjadi jika children tidak dikirim ke Panel? Coba render <Panel judul="Kosong" /> tanpa konten di dalamnya dan amati hasilnya.

Penutup

props.children mengubah cara kita berpikir tentang komponen, dari sekadar "fungsi yang menghasilkan tampilan" menjadi "wadah yang bisa diisi". Pola ini membuat komponen menjadi jauh lebih reusable karena mereka tidak perlu tahu tentang konten yang akan mereka tampilkan.

Sejauh ini komponen yang kita buat semuanya statis, sekali dirender, tampilannya tidak berubah kecuali props-nya berubah dari luar. Padahal aplikasi nyata penuh dengan interaksi: tombol yang diklik, form yang diisi, nilai yang berubah saat pengguna melakukan sesuatu. Untuk menangani ini, React punya mekanisme bernama event handling: dan itulah yang akan kita bahas di bab berikutnya.

Referensi

  1. 1 Passing Props to a Component: React Documentation
  2. 2 Thinking in React: React Documentation