程式碼異味：程式碼庫中您無法忽視的警告標誌

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:

• bahasa pengaturcaraan yang anda gunakan
• metodologi pembangunan pasukan anda ikut
• keutamaan peribadi pembangun

---

Mengapa Anda Perlu Mengambil berat tentang Bau Kod?

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:

1. Kebolehselenggaraan
   
   Kod kembung atau tidak jelas adalah mimpi ngeri untuk dikekalkan. Ia memperlahankan penyahpepijatan dan meningkatkan kemungkinan memperkenalkan pepijat.

2. Skalabiliti
   
   Kod berbau menyukarkan penskalaan aplikasi anda. Apabila pangkalan kod anda berkembang, isu asas boleh menyebabkan masalah eksponen.

3. 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.

---

Bau Kod Biasa (dan Cara Membaikinya)

Mari kita terokai beberapa bau kod dan strategi yang paling biasa untuk membersihkannya.

1. Kod Kembung

? Kaedah atau Kelas Panjang

Apabila kaedah atau kelas berkembang terlalu lama, kaedah atau kelas menjadi sukar untuk difahami, diuji dan diselenggara.

Contoh:

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 Berlebihan

Komen yang berlebihan boleh menunjukkan bahawa kod itu tidak jelas.

Contoh:

// Calculate the total price after applying the discount
let totalPrice = price - (price * discount);

Penyelesaian: Kod refactor untuk mendokumentasikan diri.

let totalPrice = applyDiscount(price, discount);

---

2. Penyalahgunaan Berorientasikan Objek

? Tukar Kenyataan

Tukar pernyataan yang berurusan dengan tingkah laku khusus jenis selalunya boleh digantikan dengan polimorfisme dalam pengaturcaraan berorientasikan objek.

Contoh:

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;
    }
}

? Bidang Sementara

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.

---

3. Ketegaran

? Perubahan Bercapah

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.

? Pembedahan senapang patah

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.

---

4. Kerumitan Yang Tidak Diperlukan

? Kod Pendua

Mempunyai sekeping kod yang sama di beberapa tempat boleh menyebabkan pepijat dan sakit kepala penyelenggaraan.

Contoh:

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

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.

---

5. Gandingan Ketat

? Ciri Iri hati

Apabila sesuatu kaedah sangat bergantung pada data objek lain dan bukannya kaedahnya sendiri, itu adalah tanda gandingan yang ketat.

Example:

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;
    }
}

? Inappropriate Intimacy

Classes that rely too heavily on each other’s internal details create unnecessary dependencies.

Solution: Enforce stricter encapsulation and reduce reliance on internal data.

---

Additional Code Smells to Watch Out For

• Magic Numbers Replace unexplained numbers with named constants to improve readability and maintainability.

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.

---

How to Deal with Code Smells

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:

1. 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.

2. Incremental Changes
   
   You don’t have to fix everything at once. Start with small, focused refactorings, targeting the smelliest areas of your code.

3. 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.

---

Final Thoughts

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中文網其他相關文章！