Comment discipliner votre code avec le refactoring (inclut des exemples PHP)

Publié: 2021-06-22

Comme beaucoup d'autres choses dans la vie, notre code a aussi besoin d'une certaine discipline. Je suis presque sûr qu'aucun développeur au monde ne veut écrire du code impur. Cependant, le code impur existe toujours. Cela peut survenir pour diverses raisons - peut-être en raison de la pression commerciale, du manque de documentation, du manque d'interaction entre les membres de l'équipe ou de l'incompétence du développeur. Des mesures appropriées doivent être prises pour rendre le code plus propre et pour éviter les problèmes qui pourraient survenir à l'avenir à cause de cela. Heureusement, nous pouvons résoudre ces problèmes avec une technique disciplinée pour restructurer le code appelée Refactoring .

Le refactoring est une technique permettant d'améliorer la structure interne du code source du programme existant et de maintenir son comportement externe. Il s'agit d'une procédure étape par étape pour améliorer le code, ce qui nous coûterait autrement beaucoup de temps et d'efforts.

Refactorisation de code

Inconvénients du code impur

Augmenter la taille du code source en y ajoutant de nouveaux programmes sans refactoriser pendant longtemps rend le code désordonné et impur. Cela rend la maintenance et le développement ultérieur du projet très difficiles. Un code impur présente des tonnes d'inconvénients :

  1. Cela augmente le coût de maintenance du projet.
  2. L'ajout d'une nouvelle fonctionnalité prend beaucoup de temps et devient parfois impossible à ajouter.
  3. Cela ralentit l'introduction de nouvelles personnes dans le projet.
  4. Il contient du code en double.
  5. Il ne passe pas tous les tests.

Il existe de nombreux autres inconvénients, mais ces problèmes coûtent beaucoup d'argent et de temps à l'organisation.

Avantages du code propre

Un code propre et discipliné a ses propres avantages :

  1. Il ne contient pas de code en double.
  2. Il passe tous les tests.
  3. Rend le code plus lisible et plus facile à comprendre.
  4. Cela rend le code plus facile à maintenir et moins cher.

Les avantages du code propre sont nombreux. Le processus de transformation d'un code malpropre en un code propre plus facile à maintenir est appelé processus de refactoring.

Processus de refactorisation

La refactorisation doit être effectuée sous la forme d'une série de petits changements, dont chacun améliore légèrement le code existant et permet au programme de continuer à s'exécuter sans le casser. Après la refactorisation, le code devrait devenir plus propre qu'avant. S'il reste impur, alors il n'y a aucun intérêt à le refactoriser. C'est juste une perte de temps et d'efforts. Aucun nouveau code ne doit être ajouté lors de la refactorisation pour créer de nouvelles fonctionnalités. Il devrait passer tous les tests après refactorisation.

Quand refactoriser

Le refactoring doit être effectué lorsque :

  • Ajout de code en double au projet. Parce que le code dupliqué est difficile à maintenir et que les modifications à un endroit peuvent nécessiter des mises à jour dans de nombreux autres endroits.
  • Ajout d'une fonctionnalité. Le refactoring facilite l'ajout de nouvelles fonctionnalités.
  • Lors de la correction d'un bogue, vous devez refactoriser car cela rendra le bogue découvert automatiquement.
  • La revue de code est la dernière étape de la refactorisation du code avant que les modifications ne soient déployées en production.

Gérer les odeurs de code

Les problèmes sur le code sont parfois appelés odeurs de code. Ce sont les problèmes abordés lors de la refactorisation. Ils sont plus faciles à trouver et à réparer.

Par example:

  • Grandes méthodes et classes avec lesquelles il est très difficile de travailler.
  • Utilisation incomplète ou incorrecte du concept de programmation orientée objet.
  • Code qui rend difficile l'ajout de modifications.
  • Code en double et obsolète dans le projet.
  • Code fortement couplé.

Techniques de refactorisation

Les techniques de refactoring sont les étapes suivies pour refactoriser le code. Certaines des techniques de refactorisation sont :

1. La méthode d'extraction

// Problème

 function printInvoice() { $this->printHeader(); // Print details. print("name: " . $this->name); print("amount " . $this->getPrice()); }

// Solution

 function printInvoice() { $this->printBanner(); $this->printDetails($this->getPrice()); } function printDetails($price) { print("name: " . $this->name); print("amount " . $outstanding); }

Si vous avez un fragment de code qui peut être groupé, ajoutez une nouvelle méthode pour cette partie de code et remplacez l'ancien code. Cela rend le code plus isolé et supprime les doublons.

2. Extraire la variable

// Problème

 if (($student->getMarksinMath() > 60) && ($student->getMarksInPhysics() > 60) && ($student->getMarksinChemistry() > 60) && $this->pass) { // do something }

// Solution

 $mathResult = $student->getMarksinMath() > 60; $physicsResult = $student->getMarksinPhysics() > 60; $chemistryResult = $student->getMarksinChemistry() > 60; $hasPassed = $this->pass; if ($mathResult && $physicsResult && $chemistryResult && $hasPassed) { // do something }

Pour les grandes expressions comme celle affichée dans le problème, qui est très difficile à comprendre, différentes variables peuvent être créées pour chaque expression. Cela rend le code plus lisible. Mais cette méthode doit être appliquée avec prudence. Cependant, il a ses propres inconvénients. Le code s'exécutera même si la condition est fausse, ce qui n'est pas le cas dans le problème.

3. La méthode en ligne

// Problème

 function printResult() { return ($this->getResult()) ? “Pass” : “Fail”; } function getResult() { return $this->totalMarks > 300; }

// Solution

 function getRating() { return ($this->totalMarks > 300) ? “Pass” : “Fail”; }

Lorsque le corps de la méthode est plus évident, utilisez cette technique. Remplacez la méthode par le contenu de la méthode et supprimez la méthode. Il minimise le nombre de méthodes indésirables.

4. Température en ligne

// Problème

 $mathMark = $student->getMathResult(); return $mathMark > 60;

// Solution

 return $student->getMathResult() > 60;

S'il existe une variable temporaire indésirable qui ne contient que le résultat de l'expression, supprimez la variable avec l'expression elle-même. Cela aide à se débarrasser des variables inutiles.

5. Remplacer le tableau par l'objet

// Problème

 $row = []; $row[0] = "Virat Kohli"; $row[1] = 70;

// Solution

 $row = new Player(); $row->setName("Virat Kohli"); $row->setNumberofCentury(70);

S'il existe un tableau avec différents types de données, remplacez-le par un objet. Parce que les champs d'une classe sont plus faciles à documenter et à gérer que les tableaux avec différents types de données.

6. Méthode paramétrée

// Problème

 function fivePercentRaise() { } function tenPercentRaise() { }

// Solution

 function raise(percent) { }

Si plusieurs méthodes effectuent une action similaire sur les données, remplacez toutes les méthodes par une méthode et transmettez les données en tant qu'argument(s). Il supprime les méthodes en double et redondantes.

7. Séparer la requête du modificateur

// Problème

 function getInterest() { $this->interestAmount = $this->principal * 10 / 100; return $this->interestAmount; }

// Solution

 function setInterest() { $this->interestAmount = $this->principal * 10 / 100; } function getInterest() { return $this->interestAmount; }

Si une méthode renvoie une valeur et modifie l'objet, séparez les deux méthodes. Un pour la modification et un autre pour retourner le résultat. Il supprime le risque de modification involontaire d'un objet.