Refactoring merupakan proses memperbaiki struktur internal program tanpa mengubah perilaku eksternal. Kegiatan ini penting dalam pengembangan perangkat lunak karena kode yang semakin kompleks dapat menyulitkan pemeliharaan, debugging, maupun pengembangan fitur baru. Pada artikel ini, akan dibahas studi kasus refactor PHP secara formal, termasuk alasan, teknik yang digunakan, contoh kodingan, serta hasil akhir dari proses refactor.

1. Pengantar Refactor dalam Pengembangan PHP

Seiring pertumbuhan aplikasi, kode PHP yang awalnya sederhana dapat berubah menjadi sulit dipahami dan sulit dikembangkan. Hal ini biasanya disebabkan oleh beberapa faktor seperti:

• Penambahan fitur secara cepat tanpa dokumentasi yang memadai.
• Struktur kode yang tidak modular.
• Penggunaan teknik procedural di aplikasi skala besar.
• Minimnya standar coding atau review.

Refactoring bertujuan mengatasi kendala tersebut dengan memperbaiki kualitas kode agar lebih mudah dipahami, diuji, dan dikembangkan, tanpa mengubah fungsi utama aplikasi.

2. Alasan Pentingnya Refactor pada Proyek PHP

Beberapa alasan umum mengapa refactor diperlukan dalam pengembangan PHP:

a. Maintainability

Kode yang tidak terstruktur menyulitkan pengembang melakukan perubahan. Refactor membuat kode lebih modular dan bersih.

b. Performance Optimization

Refactor dapat mengoptimalkan rutinitas seperti query database, perhitungan, atau proses looping.

c. Scalability

Aplikasi yang terus berkembang membutuhkan arsitektur kode yang fleksibel.

d. Bug Reduction

Kode yang bersih mengurangi potensi bug akibat implementasi yang berulang atau tidak konsisten.

3. Studi Kasus: Refactor Kode Penghitungan Diskon

Berikut contoh kode PHP lama (sebelum refactor) yang menangani perhitungan diskon berdasarkan tipe pelanggan:

Sebelum Refactor (Legacy Code)

<?php

function getPriceAfterDiscount($price, $customerType)
{
    if ($customerType == 'regular') {
        $discount = $price * 0.05;
        return $price - $discount;
    } else if ($customerType == 'premium') {
        $discount = $price * 0.10;
        return $price - $discount;
    } else if ($customerType == 'vip') {
        $discount = $price * 0.20;
        return $price - $discount;
    } else {
        return $price;
    }
}

echo getPriceAfterDiscount(100000, 'vip');

Masalah pada Kode di Atas:

• Menggunakan banyak kondisi else if.
• Menyalin logika yang sama pada setiap blok.
• Sulit diperluas jika tipe pelanggan bertambah.
• Tidak menerapkan konsep OOP atau Open-Closed Principle (SOLID).

4. Tahap Refactoring

Refactoring dilakukan dengan menerapkan strategi berikut:

1. Menghilangkan kondisi berulang.
2. Menggunakan pendekatan berbasis konfigurasi atau class map.
3. Menerapkan OOP untuk mengakomodasi perluasan tipe pelanggan.

5. Hasil Refactor dengan Pola OOP

Setelah Refactor menggunakan Polymorphism

<?php

interface DiscountType {
    public function apply($price);
}

class RegularDiscount implements DiscountType {
    public function apply($price) {
        return $price - ($price * 0.05);
    }
}

class PremiumDiscount implements DiscountType {
    public function apply($price) {
        return $price - ($price * 0.10);
    }
}

class VipDiscount implements DiscountType {
    public function apply($price) {
        return $price - ($price * 0.20);
    }
}

class NoDiscount implements DiscountType {
    public function apply($price) {
        return $price;
    }
}

class DiscountContext {
    protected $strategy;

    public function __construct(DiscountType $strategy) {
        $this->strategy = $strategy;
    }

    public function getPrice($price) {
        return $this->strategy->apply($price);
    }
}

// Contoh penggunaan
$customerType = 'vip';
$strategies = [
    'regular' => new RegularDiscount(),
    'premium' => new PremiumDiscount(),
    'vip'     => new VipDiscount(),
];

$context = new DiscountContext(
    $strategies[$customerType] ?? new NoDiscount()
);

echo $context->getPrice(100000);

Keunggulan Setelah Refactor:

• Tidak ada pengulangan logika serupa.
• Mudah menambah tipe diskon baru cukup dengan membuat class baru.
• Mengikuti prinsip Open-Closed (OCP) dalam SOLID.
• Lebih mudah diuji dengan unit testing.

6. Hasil Evaluasi Final

Dari studi kasus ini, terdapat beberapa poin penting:

KriteriaSebelum RefactorSetelah RefactorMaintainabilityRendahTinggiScalabilityRendahTinggiDuplicationTinggiRendahTestingSulitMudahSOLID PrincipleTidakYa

Refactor memberikan dampak signifikan terhadap kualitas kode secara keseluruhan, terutama dalam proyek jangka panjang yang melibatkan banyak pengembang.

7. Best Practice Refactor dalam PHP

Beberapa praktik terbaik yang direkomendasikan:

• Gunakan Composer dan PSR-4 untuk struktur autoload.
• Terapkan prinsip SOLID dan DRY (Don't Repeat Yourself).
• Gunakan Design Patterns jika kompleksitas meningkat.
• Pastikan terdapat unit test sebelum dan sesudah refactor.
• Dokumentasikan perubahan pada setiap tahap.

Kesimpulan

Refactoring merupakan proses strategis yang meningkatkan kualitas internal kode tanpa mengubah perilaku eksternal. Studi kasus pada artikel ini menunjukkan bagaimana kode legacy dapat diubah menjadi lebih efisien, modular, dan mudah dikembangkan dengan menerapkan pendekatan OOP serta design pattern yang tepat.

Dengan memahami alasan, metode, serta contoh refactor secara nyata, pengembang dapat membangun aplikasi PHP yang lebih berkualitas dan berumur panjang.