Quelles sont les Techniques et Outils de Refactorisation que Vous Devriez Utiliser ?
Le remaniement est un processus de changements qui vous permet finalement d'obtenir un code lisible, facile à développer et à maintenir. Au cours de ces améliorations, son comportement ne doit pas changer. Par conséquent, vous devez aborder le sujet avec beaucoup de prudence et de réflexion.
Techniques de remaniement
Il existe de nombreuses façons spécifiques de remanier les éléments individuels d'une application. La sélection de techniques appropriées pour le problème en considération est la clé de l'exécution optimale du processus. Une des règles de base à suivre est que le code après remaniement doit être plus propre, et tous les tests doivent passer. Ensuite, de nouvelles fonctionnalités ne doivent absolument pas être introduites pendant le processus.
Les techniques de remaniement sont nombreuses, voire très nombreuses. Dans cet article, nous en énumérerons quelques-unes. Toutes les méthodes ne sont pas applicables à tous les langages de programmation. Les techniques de remaniement sont divisées en groupes en fonction du problème qu'elles résolvent.
Extraction, composition et simplification des méthodes et des appels
Si votre code contient des méthodes longues, compliquées et difficiles à maintenir ainsi que beaucoup de responsabilités, ce groupe de techniques de remaniement vous aidera à le nettoyer.
Extraction de la méthode
Si la méthode est longue et difficile à comprendre, la partie spécifique pouvant être regroupée doit être séparée et transférée à une méthode distincte.
Avant le remaniement:
public function printVariables() {
$this->printFoo();
print "bar: " . $this->bar;
print "foobar: " . $this->foobar;
}Après le remaniement:
public function printAll() {
$this->printFooRelated();
$this->printBarRelated();
}
public function printBarRelated() {
print “bar: “ . $this->bar;
print “foobar: “ . $this->foobar;
}Extraction de la variable
Pendant le processus de remaniement, nous pouvons rencontrer des expressions complexes qui peuvent être difficiles à comprendre au premier coup d'œil. Dans ce cas, nous essayons de séparer les différentes parties de l'expression et de les transférer aux variables.
Avant le remaniement:
if ($item->isPriceSet() && $item->getPrice() <= 100 && $user->isUserLoggedIn() && $this->isUserAllowedToBuy()) {
$this->redirectToBuyForm();
}
Après le remaniement:
$isUserAllowed = $user->isUserLoggedIn() && $this->isUserAllowedToBuy();
$isPriceAcceptable = $item->isPriceSet() && $item->getPrice() <= 100;
if ($isUserAllowed && $isPriceAcceptable) {
$this->redirectToBuyForm();
}
Méthode en ligne
Si une méthode n'est utilisée qu'une seule fois, qu'elle est petite et que son contenu en dit plus que la méthode elle-même, nous pouvons envisager de transférer le contenu de la méthode à l'endroit où elle est appelée.
Avant le remaniement:
public function getFoo() {
return $this->bar() ? self::FOO : self::FOOBAR;
}
public function bar() {
return $this->foo === ‘bar’;
}
Après le remaniement:
public function getFoo() {
return $this->foo === ‘bar’ ? self::FOO : self::FOOBAR;
}
Déplacement de fonctionnalités entre objets
S'il y a une méthode dans la fonctionnalité remaniée que l'on utilise plus souvent dans une autre fonctionnalité, il faut transférer la méthode à la classe qui l'utilise le plus. Si c'est une méthode qui est utilisée à de nombreux endroits - et la classe qui l'implémente contient également d'autres responsabilités - il faut séparer la méthode en une classe distincte. Si la tâche d'une méthode donnée est seulement d'appeler une autre méthode, nous l'appelons Middle Man, sa valeur est nulle et nous devrions la supprimer.
Organisation des données
Cette catégorie comprend toutes les méthodes de remaniement qui se concentrent sur l'organisation du code. L'utilisation des méthodes contenues dans cette section rend le code plus lisible et mieux organisé.
Encapsulation de champ
Tous les champs publics d'une classe devraient être convertis en champs privés sauf s'il y a une bonne raison de ne pas le faire. L'accès à l'écriture et à la lecture de ses valeurs doit se faire en utilisant des getters et des setters.
Avant le remaniement:
class Foo {
public $bar;
}
Après le remaniement:
class Foo {
private $bar;
public function getFoo() {
return $this->bar;
}
public function setFoo($value) {
$this->bar = $value;
}
}Remplacement des nombres magiques par des constantes
Pour les développeurs écrivant les fonctionnalités, certaines parties de celles-ci peuvent être évidentes, mais cela ne sera plus le cas après quelques mois. Il est important de se rappeler cela lors de l'écriture du code. Beaucoup de gens oublient cela et laissent des chaînes et des nombres dans le code sous une forme primitive, ce qui empêche les nouvelles personnes de comprendre pleinement le code. Pendant le processus de remaniement, tous les "nombres magiques" devraient être remplacés par des constantes, avec des noms concis mais descriptifs.
Avant le remaniement:
class Foo {
public function isUnderLimit() {
return $this->bar <= 20;
}
}Après le remaniement:
class Foo {
const BAR_LIMIT = 20;
public function isUnderLimit() {
return $this->bar <= self::BAR_LIMIT;
}
}
Outils de remaniement
Il existe un certain nombre d'outils disponibles pour vous aider dans le processus de remaniement. Familiarisez-vous avec les fonctionnalités disponibles dans votre éditeur de code. Beaucoup des nouveaux environnements de développement intégré (IDE) ont des outils comme celui-ci intégrés ou disponibles en tant que plug-ins gratuits. D'autres fonctionnalités utiles qui vous permettent d'écrire un meilleur code sont :
- code sniffers - vérifient la conformité du code avec les normes,
- analyseurs de code statiques - analysent statiquement le comportement du code et vous permettent de détecter les erreurs avant d'exécuter le code.
En langage de programmation PHP, les plus courants sont php_codesniffer et phpstan.
Techniques de remaniement - résumé
Le processus de remaniement du code doit être correctement planifié et précédé par une série d'actions pour l'optimiser. Ces outils et techniques, combinés à une compréhension des parties de l'application qui sont problématiques, garantiront que le remaniement est fait de manière holistique et correcte. Les outils et techniques que nous avons présentés ici ne sont qu'un aperçu des solutions développées par l'ensemble de la communauté du développement logiciel. Si vous avez besoin d'aide pour sélectionner ces types de solutions et pour effectuer le processus de remaniement, nous pouvons nous en occuper dans le cadre du développement PHP.
