Refactoring: jelas lebih baik dari canggih
Refactoring berarti memperbaiki struktur kode tanpa mengubah apa yang dilakukannya. Kenapa tes harus ada lebih dulu, cara bekerja dalam langkah kecil yang aman, satu fungsi berantakan dirapikan dari awal sampai akhir, kenapa versi terpendek bukan yang terbaik, dan kapan sebaiknya kode dibiarkan.
Kode yang sudah jalan belum tentu selesai. Kode itu masih harus dibaca, diubah, dan di-debug, biasanya oleh orang yang tidak ikut saat kode itu ditulis. Refactoring adalah cara menjaga kode tetap dalam keadaan yang memungkinkan semua itu.
Martin Fowler, penulis buku standar tentang topik ini, mendefinisikannya dengan tepat. Sebagai kata benda: “a change made to the internal structure of software to make it easier to understand and cheaper to modify without changing its observable behavior.” Sebagai kata kerja: “to restructure software by applying a series of refactorings without changing its observable behavior.” Intinya: perubahan pada struktur internal supaya lebih mudah dipahami dan lebih murah diubah, tanpa mengubah perilaku yang terlihat dari luar.
Frasa kuncinya muncul dua kali: without changing its observable behavior. Refactoring bukan memperbaiki bug, dan bukan menambah fitur. Programnya melakukan hal yang persis sama setelahnya. Yang berbeda hanya kodenya.
Tes dulu, selalu
Bagaimana Anda tahu perilakunya tidak berubah? Tidak akan tahu, kecuali Anda memeriksanya. Jadi refactoring dimulai dengan tes: characterization test dari bagian 12 kalau kodenya belum punya tes, atau unit test dari bagian 14 kalau sudah ada.
Situs Fowler menjelaskan caranya: “Its heart is a series of small behavior preserving transformations.” Intinya serangkaian perubahan kecil yang menjaga perilaku. Setiap langkahnya kecil: ganti satu nama, ekstrak satu fungsi, hapus satu duplikasi. Setelah setiap langkah, jalankan tes. Kalau lulus, commit (bagian 16) lalu ambil langkah berikutnya. Kalau gagal, masalahnya ada di beberapa baris yang barusan diubah, jadi mudah ditemukan atau dibatalkan.
Penulisan ulang besar-besaran melewatkan semua ini, dan karena itu sering merusak hal-hal yang baru ketahuan jauh kemudian.
Satu fungsi yang berantakan
Ini fungsi yang menghitung ringkasan pesanan. Fungsinya jalan, dan kode seperti ini ada di setiap proyek sungguhan:
def proc(o):
t = 0
for i in o["items"]:
if i["qty"] > 0:
if i["qty"] >= 10:
t += i["price"] * i["qty"] * 95 // 100
else:
t += i["price"] * i["qty"]
if o["member"]:
if t > 500000:
s = 0
else:
s = 15000
else:
if t > 1000000:
s = 0
else:
s = 25000
return {"subtotal": t, "shipping": s, "total": t + s}
Ada beberapa code smell, dalam arti “any characteristic of source code that hints at a deeper problem”, ciri kode yang mengisyaratkan masalah yang lebih dalam: nama yang tidak bermakna (proc, o, t, s), magic number (bagian 11), percabangan empat tingkat, dan dua pekerjaan berbeda, harga per baris dan ongkos kirim, tercampur dalam satu fungsi. Perhatikan bahwa “Code smells are usually not bugs”: code smell biasanya bukan bug. Kode ini benar. Hanya saja lebih sulit diubah daripada seharusnya.
Langkah 0: kunci perilakunya. Lima kasus yang mencakup pesanan biasa, member, gratis ongkir dengan diskon grosir, baris refund, dan pesanan kosong:
CASES = [
({"member": False, "items": [{"price": 85000, "qty": 2}]},
{"subtotal": 170000, "shipping": 25000, "total": 195000}),
({"member": True, "items": [{"price": 85000, "qty": 2}]},
{"subtotal": 170000, "shipping": 15000, "total": 185000}),
({"member": True, "items": [{"price": 4000, "qty": 10}, {"price": 500000, "qty": 1}]},
{"subtotal": 538000, "shipping": 0, "total": 538000}),
({"member": False, "items": [{"price": 100, "qty": -1}]},
{"subtotal": 0, "shipping": 25000, "total": 25000}),
({"member": False, "items": []},
{"subtotal": 0, "shipping": 25000, "total": 25000}),
]
Lalu serangkaian langkah kecil, masing-masing diikuti menjalankan tes:
- Ganti nama
procmenjadisummarize_order,omenjadiorder,tmenjadisubtotal,smenjadishipping. - Ekstrak harga satu baris ke
line_total(price, qty). Ubahifbersarang menjadi return lebih awal untukqty <= 0. - Ekstrak ongkos kirim ke
shipping_fee(subtotal, tier). - Ganti magic number dengan tabel bernama, sehingga “member” dan “regular” menjadi data, bukan cabang.
Hasilnya:
FREE_SHIPPING_ABOVE = {"member": 500_000, "regular": 1_000_000}
SHIPPING_FEE = {"member": 15_000, "regular": 25_000}
def line_total(price, qty):
if qty <= 0:
return 0
total = price * qty
if qty >= 10:
total = total * 95 // 100
return total
def shipping_fee(subtotal, tier):
if subtotal > FREE_SHIPPING_ABOVE[tier]:
return 0
return SHIPPING_FEE[tier]
def summarize_order(order):
tier = "member" if order["member"] else "regular"
subtotal = sum(line_total(i["price"], i["qty"]) for i in order["items"])
shipping = shipping_fee(subtotal, tier)
return {"subtotal": subtotal, "shipping": shipping, "total": subtotal + shipping}
Jadi 24 baris, dari semula 19. Lebih pendek memang tidak pernah jadi tujuannya. Setiap fungsi sekarang mengerjakan satu hal, punya nama yang menjelaskan apa, dan bisa dites sendiri. Aturan bisnisnya (batas dan ongkos) ada di atas, tempat siapa pun bisa menemukannya. Dan kelima kasus yang sama lulus, untuk versi lama maupun versi baru:
15 passed in 0.02s
Buat perubahannya mudah, lalu lakukan perubahan yang mudah
Refactoring terbayar saat perubahan berikutnya datang. Misalnya bisnis menambah tingkat “gold” dengan gratis ongkir untuk semua pesanan.
Di proc yang asli, itu berarti satu cabang bersarang lagi di dalam if ongkir, di samping dua cabang yang sudah ada. Di versi yang sudah di-refactor, cukup dua entri di tabel:
FREE_SHIPPING_ABOVE["gold"] = 0
SHIPPING_FEE["gold"] = 0
shipping_fee(170000, "gold") → 0
shipping_fee(170000, "member") → 15000
shipping_fee(170000, "regular") → 25000
Kent Beck merangkum pendekatan ini dalam satu kalimat, dikutip oleh Fowler: “make the change easy, then make the easy change”. Buat perubahannya jadi mudah, lalu lakukan perubahan yang mudah itu. Versi lengkapnya menambahkan peringatan: “make the change easy (warning: this may be hard), then make the easy change”, yang membuat perubahannya mudah itu sendiri bisa jadi sulit. Fowler menyebut ini preparatory refactoring: sebelum menambah fitur, bentuk ulang kodenya supaya fitur itu masuk dengan wajar.
Satu aturan lagi dari gagasan yang sama: jangan refactor dan mengubah perilaku dalam langkah yang sama. Fowler menggambarkannya sebagai dua topi: “When you’re wearing the refactoring hat, every change you make preserves observable behavior”, dan topi itu “keeps the tests green”. Saat memakai topi refactoring, setiap perubahan menjaga perilaku dan tes tetap hijau. Refactor dengan tes yang hijau, commit, lalu ganti topi dan tambahkan fiturnya. Dua commit, masing-masing mudah di-review.
Canggih tidak sama dengan baik
Ini versi ketiga. Lulus lima tes yang sama:
def proc(o):
return (lambda t: {"subtotal": t, "shipping": (s := 0 if t > (5e5 if o["member"] else 1e6) else (15000 if o["member"] else 25000)), "total": t + s})(sum(i["price"] * i["qty"] * (95 if i["qty"] >= 10 else 100) // 100 for i in o["items"] if i["qty"] > 0))
Dua baris. Lambda, operator walrus, ekspresi kondisional bersarang. Canggih, dan yang paling buruk di antara ketiganya. Coba tambahkan tingkat gold ke sana. Coba cari batas gratis ongkirnya. Perhatikan juga bahwa 5e5 dan 1e6 adalah float, perubahan tipe dari versi asli yang kebetulan aman di sini tapi bisa saja tidak di tempat lain (bagian 2).
Zen of Python punya tiga baris untuk ini:
“Simple is better than complex.” “Readability counts.” “If the implementation is hard to explain, it’s a bad idea.”
Sederhana lebih baik daripada rumit, keterbacaan itu penting, dan kalau implementasinya sulit dijelaskan, itu ide yang buruk. Kode canggih dioptimalkan untuk saat menulisnya. Kode yang jelas dioptimalkan untuk setiap saat sesudahnya, dan itu jauh lebih banyak.
Langkah yang sama di PHP
Percabangan yang terlalu dalam adalah salah satu code smell paling umum, di bahasa apa pun. Pengecekan refund dengan setiap kondisi bersarang:
function canRefundNested(array $order, int $daysSincePaid): bool {
if ($order['status'] === 'paid') {
if ($daysSincePaid <= 7) {
if (!$order['digital']) {
return true;
} else {
return false;
}
} else {
return false;
}
} else {
return false;
}
}
Logika yang sama dengan guard clause: tangani setiap alasan untuk menolak lebih dulu, dan langsung return.
function canRefund(array $order, int $daysSincePaid): bool {
if ($order['status'] !== 'paid') {
return false;
}
if ($daysSincePaid > 7) {
return false;
}
return !$order['digital'];
}
Mengecek keduanya pada kasus yang sama:
paid digital=false days=3 nested=true guard=true same
paid digital=true days=3 nested=false guard=false same
paid digital=false days=10 nested=false guard=false same
pending digital=false days=1 nested=false guard=false same
Perilakunya sama. Sekarang setiap aturan adalah satu if yang bisa dibaca sendiri, dan menambah aturan keempat berarti menambah satu if lagi.
Refactoring yang umum
Anda tidak butuh katalog untuk memulai. Beberapa langkah ini mencakup kebanyakan perapian sehari-hari:
- Ganti nama variabel, fungsi, atau class supaya namanya menjelaskan isinya. Editor bisa melakukannya dengan aman di seluruh proyek.
- Ekstrak fungsi: beri nama pada sebongkah kode. Kalau Anda ingin menulis komentar di atas sebuah blok untuk menjelaskannya, komentar itu kemungkinan besar adalah nama fungsinya.
- Inline: kebalikannya, saat sebuah fungsi atau variabel menambah nama tapi tidak menambah kejelasan.
- Ganti magic number dengan konstanta bernama.
- Guard clause alih-alih percabangan dalam.
- Ganti kondisional dengan data: tabel atau map alih-alih rangkaian
if, seperti tingkat ongkir tadi. - Hapus duplikasi, tapi jangan terlalu cepat. Rule of three: “two instances of similar code do not require refactoring, but when similar code is used three times, it should be extracted into a new procedure.” Dua kode yang mirip belum perlu digabung; saat muncul ketiga kalinya, baru diekstrak. Dua bagian yang mirip bisa saja berkembang ke arah berbeda. Di kemunculan ketiga, polanya sudah jelas.
- Hapus kode mati. Git mengingatnya kalau suatu saat dibutuhkan lagi.
Kapan sebaiknya tidak refactor
- Tidak ada tes dan tidak ada waktu untuk menulisnya. Tanpa jaring pengaman, “merapikan” hanyalah risiko.
- Kode yang toh akan dihapus atau ditulis ulang.
- Kode yang tidak perlu diubah siapa pun. Kode jelek tapi stabil di sudut yang tidak pernah disentuh boleh tetap jelek.
- Dalam commit yang sama dengan perbaikan bug atau fitur. Topi terpisah, commit terpisah.
- Sekadar menyesuaikan selera. Kalau gaya tim berbeda dari selera Anda tapi konsisten, konsistensi yang menang.
Saat terbaik untuk refactor biasanya tepat sebelum Anda mengubah sesuatu: Anda sedang membaca kode itu, dan Anda akan langsung merasakan manfaat membuatnya lebih jelas.
Kenapa ini penting sehari-hari
- Perubahan jadi lebih murah. Waktu yang dipakai untuk memperjelas kode terbayar setiap kali ada yang menyentuhnya.
- Lebih sedikit bug yang bisa bersembunyi di kode yang jelas. Percabangan dalam dan nama yang samar adalah tempat kondisi yang salah luput dari perhatian.
- Review lebih mudah. Commit refactoring dengan tes hijau dan commit fitur masing-masing mudah di-review; kalau tercampur, keduanya jadi sulit.
- AI pandai refactoring, dan tetap percaya diri saat salah. Minta satu refactoring kecil setiap kali, jalankan tes setelahnya, dan baca diff-nya. Aturannya tidak berubah hanya karena yang mengetik adalah sebuah alat.
Coba sendiri
- Salin
procyang asli beserta lima kasus tesnya. Lakukan sendiri empat langkah refactoring, dan jalankan tes setelah setiap langkah. - Tambahkan tingkat gold ke
procyang asli dan ke versi yang sudah di-refactor. Bandingkan diff-nya. - Cari fungsi dengan tiga tingkat percabangan atau lebih di kode Anda dan tulis ulang dengan guard clause. Cek dengan beberapa kasus sebelum dan sesudah.
- Cari sesuatu yang “canggih” yang Anda tulis dulu. Masih bisakah Anda menjelaskannya dalam satu kalimat? Kalau tidak, tulis ulang dengan sederhana.
Ringkasan
- Refactoring mengubah struktur tanpa mengubah perilaku yang terlihat.
- Tes dulu, lalu langkah kecil, jalankan tes dan commit setelah setiap langkah.
- Tujuannya jelas, bukan pendek: nama yang baik, satu tugas per fungsi, aturan bernama, percabangan dangkal.
- Buat perubahannya mudah, lalu lakukan perubahan yang mudah: refactor sebelum menambah fitur, dalam commit terpisah.
- Kode canggih murah ditulis dan mahal dibaca; pilih versi yang sederhana.
- Langkah umum: ganti nama, ekstrak, inline, konstanta bernama, guard clause, data alih-alih kondisional, hapus duplikasi setelah kemunculan ketiga.
- Ketahui kapan kode sebaiknya dibiarkan.
Referensi
- Martin Fowler, DefinitionOfRefactoring, refactoring.com, dan An example of preparatory refactoring.
- PEP 20 – The Zen of Python.
- Code smell dan Rule of three (computer programming), Wikipedia.