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:
// 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:
// 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
classJavaScript, bukanfunction - Mengextend
Componentyang diimpor dari React - JSX dikembalikan di dalam method
render(), bukan langsung dari fungsi
Cara penggunaan di JSX tetap sama persis:
<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:
// 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:
// 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:
constructordipanggil pertama kali saat komponen dibuat. Baris pertama wajibsuper(props), ini meneruskanpropske class indukComponent.- State disimpan di
this.statesebagai objek biasa. - Untuk mengubah state, gunakan
this.setState(), jangan pernah langsung mengubahthis.state.jumlah = 1karena 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:
// 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:
<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:
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:
constructor, inisialisasi state dan bindingrender, menghasilkan JSXcomponentDidMount, dipanggil setelah komponen muncul di layar
componentDidMount adalah tempat yang tepat untuk mengambil data dari API atau memasang event listener:
// 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:
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:
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.
// 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:
// 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:
| Aspek | Class Component | Functional Component |
|---|---|---|
| Sintaks | class Foo extends Component | function Foo() |
| State | this.state + this.setState() | useState() |
| Efek samping | componentDidMount, componentDidUpdate, componentWillUnmount | useEffect() |
| Props | this.props | Argumen fungsi |
| Error boundary | Didukung | Belum didukung |
| Verbositas | Lebih panjang | Lebih ringkas |
| Rekomendasi React | Hindari untuk kode baru | Gunakan 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:
-
Ubah komponen
KonterTugasKelasyang sudah kita buat menjadi functional component menggunakanuseState. Pastikan perilakunya identik, tombol tambah tetap berfungsi. -
Buat class component
) dan memperbarui setiap detik menggunakanJamDigitalyang menampilkan waktu saat ini (jam:menitsetInterval. Jangan lupa bersihkan interval dicomponentWillUnmount. -
Bungkus
DaftarTugasdiApp.jsxdenganBatasPenanganError. Untuk menguji, tambahkan sementarathrow new Error('test')di dalamrender()komponenDaftarTugasdan 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.