Jika anda seorang pengekod, anda mungkin mengalami kod yang terasa "tidak aktif"—ia adalah lebih sukar untuk dikekalkan, difahami atau diskalakan. Tanda amaran biasa dalam pangkalan kod anda ini, yang dikenali sebagai bau kod, adalah petunjuk bahawa ada sesuatu yang tidak betul. Sama seperti bau busuk menunjukkan sesuatu yang busuk, bau kod membayangkan kemungkinan masalah dengan reka bentuk atau pelaksanaan kod anda.
Sebelum menyelam, mari jelaskan:
Istilah "bau" ialah metafora, membandingkan kod bermasalah dengan bau busuk. Apa yang membentuk bau kod boleh menjadi subjektif, bergantung pada:
Mengabaikan bau kod adalah seperti menangguhkan penyelenggaraan kereta—ia mungkin tidak menyebabkan masalah hari ini, tetapi lama kelamaan, ia boleh menyebabkan kerosakan besar. Inilah sebab mengapa anda perlu mengambil berat:
Kebolehselenggaraan
Kod kembung atau tidak jelas adalah mimpi ngeri untuk dikekalkan. Ia memperlahankan penyahpepijatan dan meningkatkan kemungkinan memperkenalkan pepijat.
Skalabiliti
Kod berbau menyukarkan penskalaan aplikasi anda. Apabila pangkalan kod anda berkembang, isu asas boleh menyebabkan masalah eksponen.
Hutang Teknikal
Mengabaikan bau kod adalah seperti mengumpul hutang—akhirnya anda perlu membayar balik, selalunya dengan faedah, dalam bentuk penulisan semula atau penyahpepijatan yang memakan masa.
Mari kita terokai beberapa bau kod dan strategi yang paling biasa untuk membersihkannya.
Apabila kaedah atau kelas berkembang terlalu lama, kaedah atau kelas menjadi sukar untuk difahami, diuji dan diselenggara.
function processOrder(order) {
validateOrder(order);
calculateDiscount(order);
applyTaxes(order);
updateInventory(order);
sendConfirmation(order);
}
Walaupun kaedah ini kelihatan baik, ia melaksanakan terlalu banyak tugas, menjadikannya sukar untuk diikuti.
Penyelesaian: Pecahkan kaedah yang panjang kepada fungsi satu guna yang lebih kecil.
function processOrder(order) {
validateOrder(order);
applyDiscountsAndTaxes(order);
finalizeOrder(order);
}
function applyDiscountsAndTaxes(order) {
calculateDiscount(order);
applyTaxes(order);
}
Komen yang berlebihan boleh menunjukkan bahawa kod itu tidak jelas.
// Calculate the total price after applying the discount let totalPrice = price - (price * discount);
Penyelesaian: Kod refactor untuk mendokumentasikan diri.
let totalPrice = applyDiscount(price, discount);
Tukar pernyataan yang berurusan dengan tingkah laku khusus jenis selalunya boleh digantikan dengan polimorfisme dalam pengaturcaraan berorientasikan objek.
function getArea(shape) {
switch(shape.type) {
case 'circle':
return Math.PI * shape.radius ** 2;
case 'square':
return shape.side * shape.side;
}
}
Penyelesaian: Gunakan polimorfisme untuk mengendalikan tingkah laku khusus bentuk.
class Shape {
getArea() {
throw "Must be implemented by subclass";
}
}
class Circle extends Shape {
constructor(radius) {
super();
this.radius = radius;
}
getArea() {
return Math.PI * this.radius ** 2;
}
}
class Square extends Shape {
constructor(side) {
super();
this.side = side;
}
getArea() {
return this.side * this.side;
}
}
Medan yang hanya digunakan dalam senario tertentu boleh mengeruhkan kelas anda dan membawa kepada kerumitan yang tidak perlu.
Penyelesaian: Alihkan medan sedemikian ke pembolehubah atau parameter setempat apabila boleh, atau bahagikan tanggungjawab kepada berbilang kelas.
Apabila satu kelas perlu diubah suai atas sebab yang tidak berkaitan, ini menandakan kelas itu cuba melakukan terlalu banyak.
Penyelesaian: Gunakan Prinsip Tanggungjawab Tunggal dengan membahagikan kelas kepada unit yang lebih kecil dan lebih fokus.
Apabila perubahan memerlukan pengubahsuaian berbilang kelas, ia menandakan modulariti yang lemah. Ini boleh menyebabkan pemfaktoran semula atau penambahan ciri menyakitkan.
Penyelesaian: Kenal pasti sebab perubahan berselerak dan refactor dengan mengumpulkan logik yang berkaitan bersama.
Mempunyai sekeping kod yang sama di beberapa tempat boleh menyebabkan pepijat dan sakit kepala penyelenggaraan.
function calculateTotalPrice(price, tax) {
return price + (price * tax);
}
function calculateDiscountedPrice(price, discount, tax) {
let discountedPrice = price - (price * discount);
return discountedPrice + (discountedPrice * tax);
}
Penyelesaian: Ekstrak logik biasa ke dalam kaedah boleh guna semula.
function calculatePrice(price, tax, discount = 0) {
let discountedPrice = price - (price * discount);
return discountedPrice + (discountedPrice * tax);
}
Kod mati ialah fungsi yang tidak digunakan lagi. Ia boleh mengacaukan pangkalan kod anda dan mengelirukan pembangun.
Penyelesaian: Alih keluar kod yang tidak digunakan secara kerap untuk memastikan pangkalan kod anda bersih dan ringkas.
Apabila sesuatu kaedah sangat bergantung pada data objek lain dan bukannya kaedahnya sendiri, itu adalah tanda gandingan yang ketat.
function getDiscount(customer) {
return customer.purchaseHistory.totalAmount > 1000 ? 0.1 : 0;
}
Solution: Consider moving the behavior to the object itself.
class Customer {
getDiscount() {
return this.purchaseHistory.totalAmount > 1000 ? 0.1 : 0;
}
}
Classes that rely too heavily on each other’s internal details create unnecessary dependencies.
Solution: Enforce stricter encapsulation and reduce reliance on internal data.
Example:
const SALES_TAX = 0.07; let total = price + (price * SALES_TAX);
Deep Nesting
Simplify deeply nested loops or conditionals for better readability. Consider early returns or extracting methods.
Long Parameter Lists
Refactor methods that take many parameters by using parameter objects or reducing the method’s responsibility.
Code smells don’t mean your code is broken, but they are early indicators that your design may need improvement. Here's how you can deal with them:
Refactoring
The most effective way to deal with code smells is through refactoring—improving the internal structure of your code without changing its external behavior.
Incremental Changes
You don’t have to fix everything at once. Start with small, focused refactorings, targeting the smelliest areas of your code.
Testing
Before you refactor, ensure that your code has adequate tests in place. This helps you catch regressions and verify that the refactored code behaves as expected.
Recognizing and addressing code smells is crucial for maintaining healthy, scalable, and maintainable code. Think of it as preventative care—cleaning up these smells early will save you time, effort, and headaches down the line. Keep an eye out for these common warning signs, and make refactoring a regular part of your coding process!
以上是程式碼異味：程式碼庫中您無法忽視的警告標誌的詳細內容。更多資訊請關注PHP中文網其他相關文章！
