Komponen dan Props

BAB 18: Render List

Render array data menjadi daftar elemen dengan .map(), filter data dengan .filter(), dan pahami mengapa prop key adalah kunci performa rendering list.

Coba perhatikan kembali App.jsx yang kita tulis di bab sebelumnya. Setiap KartuTugas dideklarasikan secara manual satu per satu, lengkap dengan props yang di-hardcode langsung di JSX.

React JSXJSX
// Potongan dari App.jsx (bab sebelumnya)
<KartuTugas judul="Buat halaman login" status="Aktif" nomor={1} onPilih={pilihTugas} />
<KartuTugas judul="Setup database" status="Selesai" nomor={2} onPilih={pilihTugas} />

Ini bekerja kalau tugasnya dua. Tapi bayangkan aplikasi manajemen tugas yang sesungguhnya, datanya bisa puluhan, ratusan, dan terus bertambah. Menulis KartuTugas manual untuk setiap data jelas bukan pendekatan yang masuk akal. Yang kita butuhkan adalah cara mengubah array data menjadi array elemen React secara otomatis.

Merender List dengan map()

JavaScript punya method .map() yang mengambil setiap item dalam array, menjalankan sebuah fungsi terhadapnya, dan mengembalikan array baru berisi hasilnya. Di React, kita memanfaatkan hal yang persis sama, hanya saja hasilnya adalah elemen JSX.

Kita mulai dari yang sederhana. Alih-alih menulis dua KartuTugas secara manual, kita simpan data tugas di dalam array, lalu gunakan .map() untuk merendernya:

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

const daftarTugas = [
  { id: 1, judul: 'Buat halaman login', status: 'Aktif', prioritas: true },
  { id: 2, judul: 'Setup database', status: 'Selesai', prioritas: false },
  { id: 3, judul: 'Integrasi API pembayaran', status: 'Aktif', prioritas: true },
  { id: 4, judul: 'Tulis unit test', status: 'Aktif', prioritas: false },
]

function App() {
  const pilihTugas = (nomor, judul) => {
    alert(`Memilih tugas #${nomor}: ${judul}`)
  }

  return (
    <HalamanLayout judul="Dashboard">
      <Panel judul="Semua Tugas">
        {daftarTugas.map((tugas) => (
          <KartuTugas
            key={tugas.id}
            judul={tugas.judul}
            status={tugas.status}
            nomor={tugas.id}
            prioritas={tugas.prioritas}
            onPilih={pilihTugas}
          />
        ))}
      </Panel>
    </HalamanLayout>
  )
}

export default App

Sekarang tidak peduli arraynya berisi 4 atau 400 item, kode JSX-nya tetap sama. .map() mengiterasi setiap objek di daftarTugas, dan untuk setiap item, mengembalikan sebuah <KartuTugas /> dengan props yang diambil dari data objek tersebut.

Ada satu props asing di sana yang belum pernah kita gunakan sebelumnya: key. Kita akan bahas mengapa ia ada di section berikutnya. Tapi sebelum itu, perhatikan bahwa .map() mengembalikan array elemen JSX, dan React tahu persis bagaimana merender array, ia menampilkan setiap elemen di dalam array secara berurutan.

Kenapa key Wajib Ada

Jika kamu menghapus props key dari kode di atas, React tetap merender list-nya. Tapi di console browser, muncul peringatan:

CodeTEXT
Warning: Each child in a list should have a unique "key" prop.

Ini bukan sekadar peringatan kosmetik. key adalah cara React membedakan satu elemen list dari elemen lainnya. Tanpa key yang unik, React tidak bisa menentukan elemen mana yang berubah, ditambah, atau dihapus ketika data berubah.

Bayangkan kamu punya empat kartu tugas yang terjajar. Kalau pengguna menghapus kartu kedua, React perlu tahu bahwa yang hilang adalah kartu dengan ID 2, bukan kartu di posisi kedua. Perbedaan ini krusial, karena posisi bisa bergeser, tapi identitas (key) tetap.

Aturan Key

Beberapa aturan yang perlu diingat:

  • Key harus unik di antara saudara (siblings): dua item dalam satu list tidak boleh punya key yang sama. Tapi boleh ada key yang sama di list yang berbeda.
  • Key tidak boleh berubah: jangan generate key saat rendering berlangsung. Key harus stabil dari render ke render.
  • Key tidak diteruskan sebagai props: React menggunakan key secara internal. Jika komponen anak membutuhkan nilai ID, kirim sebagai props terpisah (seperti nomor di contoh kita).

Sumber Key yang Tepat

Dari mana mendapatkan nilai key? Bergantung pada asal datanya:

Sumber dataKey yang digunakan
Database (API, backend)ID unik dari database (id, _id, uuid)
Data lokal yang dibuat usercrypto.randomUUID() saat item dibuat
Data statis yang tidak berubahIndeks array (sebagai pilihan terakhir)

Jangan gunakan indeks array sebagai key pada list yang dinamis, list yang itemnya bisa ditambah, dihapus, atau diurutkan ulang. Indeks bergeser ketika item berubah, dan ini menyebabkan React salah mencocokkan komponen dengan datanya. Hasilnya: bug halus yang sulit dilacak, seperti input yang isinya "melompat" ke baris lain.

Memfilter Data Sebelum Render

Sering kali kita tidak ingin menampilkan seluruh isi array. Misalnya, di dashboard tugas kita, mungkin ada kebutuhan menampilkan hanya tugas yang masih aktif. Method .filter() menangani ini dengan elegan, ia mengembalikan array baru berisi item yang memenuhi kondisi tertentu.

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

const daftarTugas = [
  { id: 1, judul: 'Buat halaman login', status: 'Aktif', prioritas: true },
  { id: 2, judul: 'Setup database', status: 'Selesai', prioritas: false },
  { id: 3, judul: 'Integrasi API pembayaran', status: 'Aktif', prioritas: true },
  { id: 4, judul: 'Tulis unit test', status: 'Aktif', prioritas: false },
  { id: 5, judul: 'Deploy ke staging', status: 'Selesai', prioritas: false },
]

function App() {
  const pilihTugas = (nomor, judul) => {
    alert(`Memilih tugas #${nomor}: ${judul}`)
  }

  const tugasAktif = daftarTugas.filter((tugas) => tugas.status === 'Aktif')
  const tugasSelesai = daftarTugas.filter((tugas) => tugas.status === 'Selesai')

  return (
    <HalamanLayout judul="Dashboard">
      <Panel judul="Tugas Aktif">
        {tugasAktif.map((tugas) => (
          <KartuTugas
            key={tugas.id}
            judul={tugas.judul}
            status={tugas.status}
            nomor={tugas.id}
            prioritas={tugas.prioritas}
            onPilih={pilihTugas}
          />
        ))}
      </Panel>
      <Panel judul="Tugas Selesai">
        {tugasSelesai.map((tugas) => (
          <KartuTugas
            key={tugas.id}
            judul={tugas.judul}
            status={tugas.status}
            nomor={tugas.id}
            prioritas={tugas.prioritas}
            onPilih={pilihTugas}
          />
        ))}
      </Panel>
    </HalamanLayout>
  )
}

export default App

Perhatikan bahwa .filter() dipanggil sebelum JSX, di dalam body fungsi komponen, bukan di dalam return. Hasilnya disimpan ke variabel tugasAktif dan tugasSelesai, lalu masing-masing di-render dengan .map() di dalam Panel yang berbeda.

Pola filter lalu map ini sangat idiomatis di React. Kamu akan menemukannya di hampir setiap aplikasi yang bekerja dengan data list.

Merender Beberapa Elemen per Item

Kadang satu item di array perlu menghasilkan lebih dari satu elemen DOM, misalnya heading dan paragraf, tanpa wrapper <div> tambahan. Kita tidak bisa menulis dua elemen berdampingan tanpa pembungkus, tapi shorthand Fragment <>...</> tidak mendukung props key.

Solusinya: gunakan <Fragment> yang diimpor secara eksplisit.

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

const anggota = [
  { id: 'a1', nama: 'Rina', peran: 'Frontend Developer' },
  { id: 'a2', nama: 'Budi', peran: 'Backend Developer' },
  { id: 'a3', nama: 'Sari', peran: 'UI Designer' },
]

function DaftarAnggota() {
  return (
    <div className="daftar-anggota">
      {anggota.map((orang) => (
        <Fragment key={orang.id}>
          <h3>{orang.nama}</h3>
          <p>{orang.peran}</p>
        </Fragment>
      ))}
    </div>
  )
}

export default DaftarAnggota

Fragment di sini berfungsi sama seperti <>...</> (ia tidak menghasilkan elemen DOM tambahan. Bedanya, Fragment yang diimpor bisa menerima props key, yang wajib ada di dalam .map(). Hasil render-nya adalah heading dan paragraf yang rata) tanpa div pembungkus untuk setiap anggota.

Kesalahan Umum

Lupa return di map()

Ketika menggunakan arrow function dengan kurung kurawal {}, kamu harus menulis return secara eksplisit:

React JSXJSX
// Salah: tidak ada return, hasilnya undefined
{daftarTugas.map((tugas) => {
  <KartuTugas key={tugas.id} judul={tugas.judul} />
})}

// Benar: pakai return eksplisit
{daftarTugas.map((tugas) => {
  return <KartuTugas key={tugas.id} judul={tugas.judul} />
})}

// Benar: pakai kurung biasa () untuk implicit return
{daftarTugas.map((tugas) => (
  <KartuTugas key={tugas.id} judul={tugas.judul} />
))}

Perbedaannya halus tapi penting. Arrow function dengan => ( melakukan implicit return, apapun di dalam kurung langsung dikembalikan. Sedangkan => { membuat function body biasa yang butuh return eksplisit. Tanpa return, .map() mengembalikan array berisi undefined, dan React tidak merender apapun.

Menggunakan Math.random() sebagai Key

React JSXJSX
// Jangan lakukan ini
{daftarTugas.map((tugas) => (
  <KartuTugas key={Math.random()} judul={tugas.judul} />
))}

Setiap kali komponen di-render ulang, Math.random() menghasilkan nilai baru. React melihat semua key berubah, menghancurkan seluruh elemen lama, dan membuat yang baru dari awal. Ini bukan hanya masalah performa, semua state internal komponen dalam list juga hilang.

Latihan

Kembangkan aplikasi manajemen tugas yang sudah kita bangun:

  1. Tambahkan properti kategori ke setiap objek di daftarTugas dengan nilai seperti "Frontend", "Backend", atau "Desain". Lalu buat tiga Panel terpisah yang masing-masing menampilkan tugas berdasarkan kategorinya. Gunakan .filter() sebelum .map().

  2. Buat komponen DaftarLog yang menerima props logs (array string). Komponen ini merender setiap log sebagai <li> di dalam <ol>. Tentukan sendiri apa yang paling tepat dijadikan key, pikirkan baik-baik apakah indeks array aman digunakan di sini, mengingat log biasanya hanya ditambahkan di akhir dan tidak pernah diurutkan ulang.

  3. Gabungkan render kondisional dari bab sebelumnya dengan render list: tampilkan komponen PesanKosong (dari latihan bab 17) di dalam Panel jika hasil .filter() mengembalikan array kosong. Gunakan .length === 0 sebagai kondisinya.

Penutup

Render list mengubah pendekatan kita dari yang tadinya menulis komponen satu per satu menjadi membiarkan data menentukan apa yang dirender. Pola .filter().map() yang kita pelajari akan muncul di hampir setiap komponen React yang bekerja dengan koleksi data, entah itu daftar tugas, tabel produk, atau feed notifikasi.

Tapi semua data yang kita gunakan sejauh ini masih bersifat statis, ditulis langsung di dalam kode dan tidak pernah berubah selama aplikasi berjalan. Padahal di aplikasi nyata, tugas bisa ditambah, dihapus, dan statusnya bisa berubah kapan saja. Untuk membuat data yang bisa berubah dan otomatis memperbarui tampilan, komponen butuh state: dan itulah yang akan kita pelajari selanjutnya.

Referensi

  1. 1 Rendering Lists: React Documentation
  2. 2 Array.prototype.map(): MDN Web Docs
  3. 3 Array.prototype.filter(): MDN Web Docs