Menguasai Kod Bersih dalam PHP: Pengajaran Utama daripada Perjalanan Pengekodan Saya

"Menguasai Kod Bersih dalam PHP: Pengajaran Utama daripada Perjalanan Pengekodan Saya" memfokuskan pada peraturan dan contoh praktikal dan praktikal untuk membantu pembangun PHP menulis kod yang bersih, boleh diselenggara dan cekap. Di sini, kami akan memecahkan peraturan penting ini kepada bahagian yang boleh dihadam, setiap satunya disertakan dengan contoh.

1. Nama Bermakna

• Peraturan: Gunakan nama yang jelas dan deskriptif untuk pembolehubah, fungsi dan kelas.
• Mengapa: Ini menjadikan kod anda lebih mudah difahami dan diselenggara.

Contoh:

   // BAD:
   $x = 25;
   function d($a, $b) {
       return $a + $b;
   }

   // GOOD:
   $age = 25;
   function calculateSum($firstNumber, $secondNumber) {
       return $firstNumber + $secondNumber;
   }

Penerangan:

• Elakkan pembolehubah satu huruf seperti $x atau $d. Sebaliknya, gunakan nama deskriptif seperti $age atau calculateSum.
• Nama yang jelas menjadikan niat anda jelas, membantu pembangun semasa dan akan datang memahami tujuan kod anda.

2. Prinsip Tanggungjawab Tunggal (SRP)

• Peraturan: Fungsi atau kelas sepatutnya mempunyai satu sebab sahaja untuk berubah, bermakna ia hanya perlu melakukan satu perkara.
• Mengapa: Ini menjadikan kod anda lebih modular dan lebih mudah untuk difaktorkan semula.

Contoh:

   // BAD:
   class Order {
       public function calculateTotal() {
           // logic to calculate total
       }

       public function sendInvoiceEmail() {
           // logic to send email
       }
   }

   // GOOD:
   class Order {
       public function calculateTotal() {
           // logic to calculate total
       }
   }

   class InvoiceMailer {
       public function sendInvoiceEmail() {
           // logic to send email
       }
   }

Penerangan:

• Dalam contoh BURUK, kelas Pesanan bertanggungjawab untuk mengira jumlah dan menghantar e-mel. Ini melanggar SRP kerana ia mempunyai dua tanggungjawab.
• Dalam contoh BAIK, kami memisahkan kebimbangan dengan membuat kelas InvoiceMailer yang bertanggungjawab untuk tugasan e-mel, menjadikan setiap kelas lebih mudah untuk diurus dan dikemas kini.

3. Kekalkan Fungsi Kecil

• Peraturan: Fungsi harus melakukan satu perkara dan melakukannya dengan baik. Pecahkan fungsi yang besar kepada yang lebih kecil.
• Mengapa: Fungsi kecil lebih mudah difahami, diuji dan diselenggara.

Contoh:

   // BAD:
   function processOrder($order) {
       // Validate order
       if (!$this->validateOrder($order)) {
           return false;
       }

       // Calculate total
       $total = $this->calculateTotal($order);

       // Send invoice
       $this->sendInvoiceEmail($order);

       return true;
   }

   // GOOD:
   function processOrder($order) {
       if (!$this->isOrderValid($order)) {
           return false;
       }

       $this->finalizeOrder($order);
       return true;
   }

   private function isOrderValid($order) {
       return $this->validateOrder($order);
   }

   private function finalizeOrder($order) {
       $total = $this->calculateTotal($order);
       $this->sendInvoiceEmail($order);
   }

Penerangan:

• Dalam contoh BURUK, fungsi processOrder cuba melakukan segala-galanya: pengesahan, pengiraan dan menghantar invois.
• Dalam contoh BAIK, kami membahagikan tugas kepada kaedah yang lebih kecil dan lebih fokus (isOrderValid, finalizeOrder), meningkatkan kebolehbacaan dan kebolehgunaan semula.

4. Elakkan Nombor Ajaib dan Rentetan

• Peraturan: Gantikan nombor dan rentetan "ajaib" dengan pemalar bernama.
• Mengapa: Ini meningkatkan kebolehbacaan dan menjadikan kod lebih mudah untuk diubah suai.

Contoh:

   // BAD:
   if ($user->age > 18) {
       echo "Eligible";
   }

   // GOOD:
   define('MINIMUM_AGE', 18);

   if ($user->age > MINIMUM_AGE) {
       echo "Eligible";
   }

Penerangan:

• Dalam contoh BURUK, nombor 18 ialah "nombor ajaib". Anda tidak tahu apa yang diwakilinya sehingga anda menganalisis konteksnya.
• Dalam contoh BAIK, menggunakan MINIMUM_AGE menjadikan maksud jelas dan membolehkan anda menukar nilai di satu tempat tanpa mencari pangkalan kod.

5. KERING (Jangan Ulangi Sendiri)

• Peraturan: Elakkan kod pendua. Gunakan semula fungsi atau kelas di mana mungkin.
• Mengapa: Kod pendua lebih sukar untuk dikekalkan dan lebih terdedah kepada pepijat.

Contoh:

   // BAD:
   $total = $itemPrice * $quantity;
   $finalPrice = $total - ($total * $discountRate);

   $cartTotal = $cartItemPrice * $cartQuantity;
   $finalCartPrice = $cartTotal - ($cartTotal * $cartDiscountRate);

   // GOOD:
   function calculateFinalPrice($price, $quantity, $discountRate) {
       $total = $price * $quantity;
       return $total - ($total * $discountRate);
   }

   $finalPrice = calculateFinalPrice($itemPrice, $quantity, $discountRate);
   $finalCartPrice = calculateFinalPrice($cartItemPrice, $cartQuantity, $cartDiscountRate);

Penerangan:

• Dalam contoh BURUK, logik pengiraan harga diduakan.
• Dalam contoh BAIK, kami mencipta fungsi boleh guna semula hitungFinalPrice untuk mengelakkan pengulangan dan menjadikan kod lebih mudah diselenggara.

6. Gunakan Klausa Pengawal untuk Mengurangkan Bersarang

• Peraturan: Daripada pernyataan if bersarang dalam, kembali awal untuk memudahkan struktur.
• Mengapa: Klausa pengawal menghapuskan sarang yang tidak perlu, menjadikan kod lebih bersih dan lebih mudah untuk diikuti.

Contoh:

   // BAD:
   function processPayment($amount) {
       if ($amount > 0) {
           if ($this->isPaymentMethodAvailable()) {
               if ($this->isUserLoggedIn()) {
                   // Process payment
               }
           }
       }
   }

   // GOOD:
   function processPayment($amount) {
       if ($amount <= 0) {
           return;
       }
       if (!$this->isPaymentMethodAvailable()) {
           return;
       }
       if (!$this->isUserLoggedIn()) {
           return;
       }

       // Process payment
   }

Penerangan:

• Dalam contoh BURUK, logiknya sangat bersarang, menjadikannya lebih sukar untuk dibaca.
• Dalam contoh BAIK, klausa pengawal digunakan untuk kembali awal jika syarat tidak dipenuhi, meratakan struktur dan menjadikan kod lebih bersih.

7. Komen pada Kenapa, Bukan Apa

• Peraturan: Tulis ulasan untuk menerangkan sebab sesuatu berlaku, bukan perkara yang berlaku (yang sepatutnya jelas daripada kod).
• Mengapa: Komen harus memberikan nilai melebihi yang jelas, membantu menjelaskan niat dan alasan di sebalik kod.

Contoh:

   // BAD:
   // Increment age by 1
   $age++;

   // GOOD:
   // User's birthday has passed, increase age by 1
   $age++;

Penerangan:

• The BAD comment simply restates what the code does, which is obvious from the code itself.
• The GOOD comment explains why we are incrementing the age, adding meaningful context.

8. Refactor for Clarity

• Rule: Continuously refactor to improve code clarity and simplicity.
• Why: Clean code is achieved through constant refactoring to ensure that it is always readable, efficient, and maintainable.

Example:

   // Before Refactoring:
   function getDiscountedPrice($price, $isHoliday) {
       if ($isHoliday) {
           return $price * 0.9;
       } else {
           return $price;
       }
   }

   // After Refactoring:
   function getDiscountedPrice($price, $isHoliday) {
       return $isHoliday ? $price * 0.9 : $price;
   }

Description:

• Refactoring transforms long-winded code into more concise, elegant versions without losing clarity. In this example, we simplified an if-else structure using a ternary operator.

---

These essential rules—derived from the journey of coding cleanly in PHP—make your code more readable, maintainable, and scalable. By applying these principles consistently, you ensure that your code is easy to understand and modify over time, regardless of the complexity of your projects.

Atas ialah kandungan terperinci Menguasai Kod Bersih dalam PHP: Pengajaran Utama daripada Perjalanan Pengekodan Saya. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!