Maîtriser le code propre en PHP : leçons clés de mon parcours de codage

"Maîtriser le code propre en PHP : leçons clés de mon parcours de codage" se concentre sur des règles et des exemples pratiques pour aider les développeurs PHP à écrire du code propre, maintenable et efficace. Ici, nous allons décomposer ces règles essentielles en parties digestes, chacune accompagnée d'un exemple.

1. Noms significatifs

• Règle : utilisez des noms clairs et descriptifs pour les variables, les fonctions et les classes.
• Pourquoi : Cela rend votre code plus facile à comprendre et à maintenir.

Exemple :

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

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

Description :

• Évitez les variables à une lettre comme $x ou $d. Utilisez plutôt des noms descriptifs comme $age ou calculateSum.
• Des noms clairs rendent votre intention explicite, aidant ainsi les développeurs actuels et futurs à comprendre le but de votre code.

2. Principe de responsabilité unique (SRP)

• Règle : Une fonction ou une classe ne doit avoir qu'une seule raison de changer, ce qui signifie qu'elle ne doit faire qu'une seule chose.
• Pourquoi : Cela rend votre code plus modulaire et plus facile à refactoriser.

Exemple :

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

Description :

• Dans l'exemple BAD, la classe Order est responsable à la fois du calcul du total et de l'envoi d'un e-mail. Cela viole le SRP car il a deux responsabilités.
• Dans l'exemple BON, nous séparons les préoccupations en créant une classe InvoiceMailer responsable des tâches de courrier électronique, ce qui rend chaque classe plus facile à gérer et à mettre à jour.

3. Gardez les fonctions petites

• Règle : Les fonctions doivent faire une chose et bien la faire. Divisez les grandes fonctions en plus petites.
• Pourquoi : Les petites fonctions sont plus faciles à comprendre, à tester et à maintenir.

Exemple :

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

Description :

• Dans l'exemple BAD, la fonction processOrder essaie de tout faire : validation, calcul et envoi d'une facture.
• Dans l'exemple GOOD, nous décomposons les tâches en méthodes plus petites et plus ciblées (isOrderValid, finalizeOrder), améliorant ainsi la lisibilité et la réutilisabilité.

4. Évitez les nombres et les chaînes magiques

• Règle : Remplacez les nombres et les chaînes « magiques » par des constantes nommées.
• Pourquoi : Cela améliore la lisibilité et rend le code plus facile à modifier.

Exemple :

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

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

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

Description :

• Dans l'exemple MAUVAIS, le chiffre 18 est un "nombre magique". Vous ne savez pas ce que cela représente tant que vous n’avez pas analysé le contexte.
• Dans l'exemple GOOD, l'utilisation de MINIMUM_AGE rend l'intention claire et vous permet de modifier la valeur en un seul endroit sans rechercher dans la base de code.

5. SEC (Ne vous répétez pas)

• Règle : Évitez de dupliquer le code. Réutilisez les fonctions ou les classes dans la mesure du possible.
• Pourquoi : Le code dupliqué est plus difficile à maintenir et plus sujet aux bugs.

Exemple :

   // 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);

Description :

• Dans l'exemple MAUVAIS, la logique de calcul du prix est dupliquée.
• Dans l'exemple BON, nous créons une fonction réutilisable calculateFinalPrice pour éviter les répétitions et rendre le code plus maintenable.

6. Utilisez des clauses de garde pour réduire l'imbrication

• Règle : Au lieu d'instructions if profondément imbriquées, revenez tôt pour simplifier la structure.
• Pourquoi : Les clauses de garde éliminent l'imbrication inutile, rendant le code plus propre et plus facile à suivre.

Exemple :

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

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

       // Process payment
   }

Description :

• Dans l'exemple MAUVAIS, la logique est profondément imbriquée, ce qui la rend plus difficile à lire.
• Dans l'exemple BON, les clauses de garde sont utilisées pour revenir plus tôt si les conditions ne sont pas remplies, aplatissant la structure et rendant le code plus propre.

7. Commentez pourquoi, pas quoi

• Règle : Écrivez des commentaires pour expliquer pourquoi quelque chose se passe, pas ce qui se passe (ce qui devrait être clair dans le code).
• Pourquoi : les commentaires doivent apporter une valeur au-delà de l'évidence, aidant à expliquer l'intention et le raisonnement derrière le code.

Exemple :

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

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

Description :

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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!