Komponen dan Props

BAB 12: Class Component

Memahami class component sebagai bentuk komponen sebelum Hooks, sintaks, lifecycle method, dan mengapa functional component kini lebih disukai.

Bab sebelumnya kita membangun komponen pertama menggunakan fungsi, dan itu memang cara yang direkomendasikan React hari ini. Tapi jika kamu membuka codebase React yang lebih lama, atau membaca tutorial yang ditulis sebelum 2019, kamu akan menemukan cara lain mendefinisikan komponen: menggunakan class.

Class component bukan sesuatu yang harus kamu gunakan untuk proyek baru, tapi memahaminya penting. Pertama, banyak proyek produksi masih menggunakan class component dan kamu perlu bisa membacanya. Kedua, satu fitur React, error boundary: hingga hari ini masih hanya bisa dibuat dengan class component.

Dari Fungsi ke Kelas

Functional component yang sudah kita buat di bab sebelumnya terlihat seperti ini:

React JSXJSX
// src/components/KartuTugas.jsx

function KartuTugas() {
  return (
    <div className="kartu-tugas">
      <h3>Buat halaman login</h3>
      <span className="badge badge-biru">Aktif</span>
    </div>
  )
}

export default KartuTugas

Class component yang setara dengan kode di atas:

React JSXJSX
// src/components/KartuTugasKelas.jsx
import { Component } from 'react'

class KartuTugasKelas extends Component {
  render() {
    return (
      <div className="kartu-tugas">
        <h3>Buat halaman login</h3>
        <span className="badge badge-biru">Aktif</span>
      </div>
    )
  }
}

export default KartuTugasKelas

Perbedaan yang langsung terlihat:

  • Menggunakan sintaks class JavaScript, bukan function
  • Mengextend Component yang diimpor dari React
  • JSX dikembalikan di dalam method render(), bukan langsung dari fungsi

Cara penggunaan di JSX tetap sama persis:

React JSXJSX
<KartuTugasKelas />

React tidak peduli apakah komponen didefinisikan sebagai fungsi atau kelas, yang penting ia mengembalikan JSX.

State di Class Component

Komponen tanpa state tidak banyak berbeda antara class dan functional. Perbedaan yang lebih kentara muncul ketika kita menambahkan state.

Di functional component, kita menggunakan useState:

React JSXJSX
// functional component dengan state
import { useState } from 'react'

function KonterTugas() {
  const [jumlah, setJumlah] = useState(0)

  return (
    <div>
      <p>Tugas aktif: {jumlah}</p>
      <button onClick={() => setJumlah(jumlah + 1)}>Tambah</button>
    </div>
  )
}

Di class component, state adalah properti objek yang diinisialisasi di constructor:

React JSXJSX
// src/components/KonterTugasKelas.jsx
import { Component } from 'react'

class KonterTugasKelas extends Component {
  constructor(props) {
    super(props)
    this.state = {
      jumlah: 0
    }
  }

  render() {
    return (
      <div>
        <p>Tugas aktif: {this.state.jumlah}</p>
        <button onClick={() => this.setState({ jumlah: this.state.jumlah + 1 })}>
          Tambah
        </button>
      </div>
    )
  }
}

export default KonterTugasKelas

Beberapa hal yang perlu diperhatikan:

  • constructor dipanggil pertama kali saat komponen dibuat. Baris pertama wajib super(props), ini meneruskan props ke class induk Component.
  • State disimpan di this.state sebagai objek biasa.
  • Untuk mengubah state, gunakan this.setState(), jangan pernah langsung mengubah this.state.jumlah = 1 karena React tidak akan mendeteksi perubahan tersebut.

this.setState() bersifat asinkron. Jangan mengandalkan this.state segera setelah memanggil setState, nilainya belum tentu sudah diperbarui. Gunakan callback atau functional update jika perlu membaca state setelah update.

Props di Class Component

Props diakses melalui this.props, berbeda dengan functional component yang menerimanya sebagai argumen fungsi:

React JSXJSX
// src/components/KartuTugasKelas.jsx
import { Component } from 'react'

class KartuTugasKelas extends Component {
  render() {
    return (
      <div className="kartu-tugas">
        <h3>{this.props.judul}</h3>
        <span className="badge badge-biru">{this.props.status}</span>
      </div>
    )
  }
}

export default KartuTugasKelas

Penggunaannya di komponen induk tetap sama:

React JSXJSX
<KartuTugasKelas judul="Buat halaman login" status="Aktif" />

Lifecycle Methods

Inilah bagian yang membuat class component terasa "berat" bagi banyak developer: lifecycle methods. Ini adalah method yang React panggil secara otomatis di momen-momen tertentu dalam kehidupan sebuah komponen.

Ada tiga fase utama dalam lifecycle komponen:

CodeTEXT
MOUNTING              UPDATING              UNMOUNTING
---------             --------              ----------
constructor           render                componentWillUnmount
render                componentDidUpdate
componentDidMount

Mounting: Komponen Pertama Kali Muncul

Ketika komponen pertama kali ditambahkan ke DOM, React menjalankan tiga hal secara berurutan:

  1. constructor, inisialisasi state dan binding
  2. render, menghasilkan JSX
  3. componentDidMount, dipanggil setelah komponen muncul di layar

componentDidMount adalah tempat yang tepat untuk mengambil data dari API atau memasang event listener:

React JSXJSX
// src/components/DaftarTugasKelas.jsx
import { Component } from 'react'

class DaftarTugasKelas extends Component {
  constructor(props) {
    super(props)
    this.state = {
      tugas: [],
      sedangMemuat: true
    }
  }

  componentDidMount() {
    // simulasi mengambil data dari API
    setTimeout(() => {
      this.setState({
        tugas: [
          { id: 1, judul: 'Buat halaman login', status: 'aktif' },
          { id: 2, judul: 'Review pull request', status: 'selesai' },
          { id: 3, judul: 'Update dokumentasi', status: 'aktif' }
        ],
        sedangMemuat: false
      })
    }, 1000)
  }

  render() {
    if (this.state.sedangMemuat) {
      return <p>Memuat tugas...</p>
    }

    return (
      <ul>
        {this.state.tugas.map(t => (
          <li key={t.id}>{t.judul}, {t.status}</li>
        ))}
      </ul>
    )
  }
}

export default DaftarTugasKelas

Updating: Komponen Diperbarui

Setiap kali props atau state berubah, komponen dirender ulang. Setelah render ulang selesai, componentDidUpdate dipanggil:

React JSXJSX
componentDidUpdate(prevProps, prevState) {
  // perbandingan dengan nilai sebelumnya penting
  // untuk menghindari infinite loop
  if (prevState.jumlah !== this.state.jumlah) {
    console.log('Jumlah tugas berubah:', this.state.jumlah)
  }
}

Bandingkan selalu nilai sebelumnya (prevState atau prevProps) dengan nilai sekarang. Jika kamu memanggil setState di dalam componentDidUpdate tanpa pengecekan ini, komponen akan masuk ke infinite loop: update memicu render, render memicu componentDidUpdate, yang memicu update lagi, dan seterusnya.

Unmounting: Komponen Dihapus

componentWillUnmount dipanggil tepat sebelum komponen dihapus dari DOM. Gunakan ini untuk membersihkan efek samping:

React JSXJSX
componentDidMount() {
  this.intervalId = setInterval(() => {
    this.setState(prev => ({ waktu: prev.waktu + 1 }))
  }, 1000)
}

componentWillUnmount() {
  // bersihkan interval agar tidak terus berjalan
  // setelah komponen dihapus
  clearInterval(this.intervalId)
}

Tanpa cleanup di componentWillUnmount, interval atau subscription yang dipasang di componentDidMount akan terus berjalan di memori meskipun komponen sudah tidak ada, ini yang disebut memory leak.

Aturan sederhana: apapun yang kamu "pasang" di componentDidMount, "lepas" di componentWillUnmount. Timer dimatikan, subscription dibatalkan, event listener dihapus.

Error Boundary

Satu kasus di mana class component masih relevan dan tidak bisa digantikan functional component adalah error boundary: komponen yang menangkap error JavaScript dari komponen anak dan menampilkan fallback UI alih-alih crash.

React JSXJSX
// src/components/BatasPenanganError.jsx
import { Component } from 'react'

class BatasPenanganError extends Component {
  constructor(props) {
    super(props)
    this.state = { adaError: false }
  }

  static getDerivedStateFromError(error) {
    // update state untuk menampilkan fallback UI
    return { adaError: true }
  }

  componentDidCatch(error, info) {
    // bisa dikirim ke layanan logging seperti Sentry
    console.error('Error tertangkap:', error, info)
  }

  render() {
    if (this.state.adaError) {
      return (
        <div className="pesan-error">
          <p>Terjadi kesalahan. Coba muat ulang halaman.</p>
        </div>
      )
    }

    return this.props.children
  }
}

export default BatasPenanganError

Cara penggunaannya: bungkus bagian UI yang ingin dijaga:

React JSXJSX
// src/App.jsx
import BatasPenanganError from './components/BatasPenanganError'
import DaftarTugas from './components/DaftarTugas'

function App() {
  return (
    <div className="app">
      <BatasPenanganError>
        <DaftarTugas />
      </BatasPenanganError>
    </div>
  )
}

export default App

Jika DaftarTugas atau komponen di dalamnya melempar error, BatasPenanganError akan menangkapnya dan menampilkan pesan error yang ramah alih-alih crash seluruh halaman.

Perbandingan: Class vs Functional

Berikut perbandingan singkat keduanya untuk kasus yang sama:

AspekClass ComponentFunctional Component
Sintaksclass Foo extends Componentfunction Foo()
Statethis.state + this.setState()useState()
Efek sampingcomponentDidMount, componentDidUpdate, componentWillUnmountuseEffect()
Propsthis.propsArgumen fungsi
Error boundaryDidukungBelum didukung
VerbositasLebih panjangLebih ringkas
Rekomendasi ReactHindari untuk kode baruGunakan ini

Kapan Masih Perlu Class Component

Untuk kode baru, hampir tidak ada alasan menggunakan class component kecuali satu: error boundary. Jika proyek kamu perlu error boundary sendiri tanpa library eksternal, class component adalah satu-satunya cara.

Untuk semua kebutuhan lain (state, efek samping, context) functional component dengan Hooks jauh lebih ringkas dan mudah diuji.

Library react-error-boundary menyediakan error boundary yang siap pakai tanpa harus menulis class component sendiri. Ini pilihan yang praktis jika kamu ingin tetap sepenuhnya di functional component.

Latihan

Buka proyek daftar-tugas yang sudah kita kerjakan:

  1. Ubah komponen KonterTugasKelas yang sudah kita buat menjadi functional component menggunakan useState. Pastikan perilakunya identik, tombol tambah tetap berfungsi.

  2. Buat class component JamDigital yang menampilkan waktu saat ini (jam:menit

    ) dan memperbarui setiap detik menggunakan setInterval. Jangan lupa bersihkan interval di componentWillUnmount.

  3. Bungkus DaftarTugas di App.jsx dengan BatasPenanganError. Untuk menguji, tambahkan sementara throw new Error('test') di dalam render() komponen DaftarTugas dan lihat apakah error boundary bekerja.

Penutup

Class component adalah cara lama React bekerja, dan memahaminya membuka kemampuan membaca codebase yang lebih lama serta menangani error boundary yang masih membutuhkan sintaks ini. Tapi untuk semua hal lain, functional component dengan Hooks adalah jalannya.

Bicara soal props: kita sudah menyinggung this.props di bab ini, tapi belum benar-benar menyelami cara mengirim data dari komponen induk ke anak. Di bab berikutnya, kita akan masuk ke props secara penuh, mekanisme komunikasi searah yang membuat komponen kita bisa dinamis dan serbaguna.

Referensi

  1. 1 Component: React Documentation
  2. 2 Keeping Components Pure: React Documentation