Tips Menyusun Struktur Class yang Baik (Biar Kode Gak Ambrol)
Halo, para pejuang kode! Pernah gak sih kamu nulis class, terus tiba-tiba jadi monster raksasa yang isinya campur aduk? Method panjang, variabel berserakan, dan bikin pusing sendiri pas mau ngubah sesuatu. Tenang, kamu gak sendirian. Banyak programmer (termasuk saya dulu) pernah mengalami fase “class chaos” kayak gitu.
Nah, biar kode kamu lebih rapi, gampang di-maintain, dan gak bikin masa depanmu jadi programmer yang stres, yuk kita bahas tips menyusun struktur class yang baik. Gak perlu sok serius, santai aja.
1. Satu Class, Satu Tanggung Jawab
Ini adalah golden rule yang sering dilanggar. Prinsipnya simpel: sebuah class harus punya satu alasan untuk berubah. Misalnya, kamu punya class `User`. Jangan sekaligus ngurusin login, kirim email, simpan data, dan generate laporan. Pisahin aja.
Contoh jelek:
“`php
class User {
function login() {}
function sendEmail() {}
function generatePdfReport() {}
}
“`
Contoh lebih baik:
“`php
class User {
// hanya urusan data user
}
class UserAuthenticator {
// ngurus login
}
class EmailService {
// ngirim email
}
“`
Dengan begini, kalau ada perubahan di cara kirim email, kamu gak perlu utak-atik class User.
2. Nama yang Jelas dan Konsisten
Jangan pakai nama kayak `DataProcessor` atau `Manager` kalau bisa lebih spesifik. `InvoiceCalculator` lebih jelas daripada `DataProcessor`. Nama class harus noun (kata benda) yang mewakili entitas atau konsep.
Juga, konsisten dengan gaya penulisan (CamelCase, PascalCase, dll). Dalam banyak bahasa, class biasanya PascalCase: `class UserProfile`. Jangan campur aduk antara `userProfile` dan `Userprofile`.
3. Jangan Bikin Class Terlalu Panjang
Pernah lihat class dengan 2000 baris? Itu biasanya disebut “god class”. Hindari. Kalau class mulai terasa panjang, curigai ada tanggung jawab yang kebanyakan. Pisahin jadi beberapa class kecil.
Aturan praktis: satu method jangan lebih dari 20-30 baris. Satu class jangan lebih dari 200-300 baris. Ini gak mutlak, tapi jadi indikasi kalau ada yang salah.
4. Gunakan Constructor dengan Bijak
Constructor adalah tempat untuk inisialisasi properti yang wajib. Jangan taruh logic rumit di sini. Kalau constructor butuh banyak parameter, mungkin class itu terlalu banyak tanggung jawab. Pertimbangkan pakai parameter object atau builder pattern.
Juga, usahakan constructor tidak melakukan operasi berat seperti koneksi database atau panggilan API. Biar class mudah di-test.
5. Encapsulate Properti
Jangan biarkan properti class diakses langsung dari luar. Gunakan private atau protected, lalu sediakan getter/setter kalau perlu. Ini melindungi data internal dari modifikasi sembarangan.
Contoh:
“`php
class User {
private string $email;
public function getEmail(): string {
return $this->email;
}
public function setEmail(string $email): void {
// validasi bisa ditambahkan di sini
$this->email = $email;
}
}
“`
Kalau pakai setter, kamu bisa validasi data. Kalau properti public, orang bisa asal ubah.
6. Dependency Injection
Daripada class membuat sendiri objek yang dibutuhkan (misalnya membuat koneksi database di dalam constructor), lebih baik “disuntikkan” dari luar. Ini bikin class lebih fleksibel dan mudah diuji.
Contoh buruk:
“`php
class UserRepository {
private $db;
public function __construct() {
$this->db = new PDO(…); // keras
}
}
“`
Contoh baik:
“`php
class UserRepository {
private $db;
public function __construct(PDO $db) {
$this->db = $db;
}
}
“`
Sekarang kamu bisa ganti koneksi database kapan saja tanpa mengubah class.
7. Jangan Terlalu Banyak Inheritance
Pewarisan (inheritance) memang kuat, tapi kalau terlalu dalam bisa jadi mimpi buruk. Prefer komposisi daripada pewarisan. Artinya, class memiliki objek lain (has-a) daripada “adalah” (is-a). Lebih fleksibel dan gampang diubah.
Misalnya, daripada `class Admin extends User`, lebih baik `class Admin { private $user; }` dan delegasikan tugas ke user object.
8. Buat Interface atau Abstract Class untuk Kontrak
Kalau kamu punya beberapa class yang melakukan hal serupa tapi dengan cara berbeda, buat interface. Ini membantu polimorfisme dan memudahkan testing.
Contoh:
“`php
interface PaymentGateway {
public function charge(float $amount): bool;
}
class StripeGateway implements PaymentGateway { … }
class PaypalGateway implements PaymentGateway { … }
“`
Kode yang menggunakan `PaymentGateway` bisa bekerja dengan implementasi mana pun tanpa tahu detailnya.
9. Beri Komentar yang Berguna (Tapi Jangan Berlebihan)
Komentar sebaiknya menjelaskan why bukan what. Kode yang baik sudah menjelaskan what dengan nama method dan variabel. Komentar berguna untuk menjelaskan alasan di balik keputusan tertentu, atau detail rumit yang tidak terlihat.
Hindari komentar seperti:
“`php
// increment i by 1
$i++;
“`
Itu jelas. Lebih baik komentari kenapa kamu pakai algoritma A dibanding B.
10. Review dan Refactor Secara Berkala
Struktur class yang baik tidak lahir dalam sekali tulis. Butuh iterasi. Kalau kamu lihat ada kode yang mulai bau, jangan ragu refactor. Codebase yang sehat adalah yang terus dirawat, bukan dibiarkan membusuk.
Sempatkan waktu setiap beberapa sprint untuk “membereskan” class-class yang mulai kusut. Masa depanmu (dan tim) akan berterima kasih.
—
Nah, itu dia tips-tips sederhana buat nyusun struktur class yang baik. Intinya: jadilah programmer yang malas (dalam arti baik) – malas ngerjain hal yang sama berulang, malas ngoding panjang-panjang, dan malas pusing gara-gara kode sendiri. Dengan struktur yang rapi, hidupmu jadi lebih santai. Selamat mencoba!