Qu’est-ce que la refactorisation ?

Description

Refactorisation (Refactoring) – les modifications apportées à la structure interne du logiciel (software) pour le rendre plus facile à comprendre et plus rapide à modifier sans changer le comportement externe. Aussi, il s'agit d'une restructuration du logiciel grâce à l'application d'une séquence de refactorings sans changer le comportement externe du logiciel.

Avantages de la refactorisation :

• La refactorisation améliore la conception des logiciels. Au fil du temps, de nombreuses modifications supplémentaires sont apportées au code et le logiciel perd sa structure avec le temps. La perte de structure a un effet cumulatif. Plus il est difficile de voir la conception dans le code, plus il est difficile de la conserver et plus vite elle s’effondre. De tels changements entraînent également une redondance et une duplication du code, rendant le système plus difficile à comprendre et à modifier.
• La refactorisation rend le code logiciel plus compréhensible.

Quand vous devez effectuer une refactorisation :

• Lorsqu'une nouvelle fonctionnalité est ajoutée ;
• Lorsqu'une erreur est corrigée (fixée);
• Pendant la révision du code.

Mauvaises odeurs dans le code (Smells Catalog) :

• Duplication de codes
• Méthode longue
• Grande classe
• Une longue liste de paramètres
• Modifications divergentes
• Tir de tir
• Des fonctionnalités envieuses
• Blocs de données
• Obsession pour les types élémentaires
• Switch les opérateurs
• Hiérarchies parallèles d'imitation
• Cours paresseux
• Communauté spéculative (théorique)
• Champ temporaire
• Fils de discussion
• Agent
• Une proximité inappropriée
• Classes alternatives avec différentes interfaces
• Classe de bibliothèque incomplète
• Classes de données
• commentaires

Options de refactorisation possibles

1. Moving Features Between Objects (Transfert de code complet entre objets) :

   • Move Method (Méthode de mise en évidence) – isoler une méthode distincte si la méthode est trop longue ou contient du code nécessitant des commentaires.
   • Move Field (Champ mobile) – effectué lorsque le champ est utilisé par une autre classe plus souvent que là où il est défini.

2. Organizing Data (Disposition des données):

   • Encapsulate Field (Encapsulation de champ) - l'un des grands principes de la POO est l'encapsulation, ou le masquage de données. En rendant les données publiques, les objets peuvent lire et modifier leurs valeurs à l'insu du propriétaire des données. Par conséquent, nous fermons un tel champ et fournissons des méthodes d’accès.
   • Encapsulate Collection (Encapsulation des collections) - souvent la classe contient une collection de spécimens. Cette collection peut être un tableau, une liste, un ensemble ou un vecteur. La méthode getter ne renvoie pas l'objet de collection lui-même, car cela permettrait aux clients de modifier le contenu de la collection à l'insu de la classe qui la possède. Vous devez donc retourner la valeur renvoyée par la méthode en lecture seule et créer des méthodes pour ajouter/supprimer des éléments.

3. Composing Methods (Extraction et combinaison de code) :

   • Extract Method (Méthode de mise en évidence) – s’il existe un morceau de code qui peut être regroupé, placez-le dans une méthode distincte avec un nom qui explique son objectif. Ainsi, le nom de la méthode remplacera les commentaires.
   • Inline Method (Intégration de la méthode) – il est parfois utile de déplacer le corps d’une méthode dans le code qui l’appelle. Parfois, les corps de méthode sont aussi explicites que le nom de la méthode lui même. Il peut également y avoir une situation où il existe de nombreuses méthodes différentes dont la structure échoue, et il est donc préférable de les regrouper toutes dans une méthode générale, puis de séparer les méthodes d'une autre manière.
   • Inline Temp (Insertion d'une variable temporaire) – remplacement d'une variable temporaire à la quelle une simple expression n'est affectée qu'une seule fois. Parfois, une telle variable interfère avec d’autres refactorisations.
   • Replace Temp with Query (Remplacement d'une variable temporaire pour un appel de méthode) – est utilisé lorsqu'une variable temporaire est utilisée pour stocker la valeur d'une expression. Dans ce cas, nous remplaçons l'expression par une méthode et remplaçons toutes les références dans le code à cette variable par la nouvelle méthode.
   • Split Temporary Variable (Diviseur à variable temporaire) – s'applique si une seule variable temporaire est utilisée pour attribuer plusieurs résultats à différents résultats (sauf s'il s'agit d'une variable utilisée dans une boucle au sein d'une boucle et non d'une variable pour accumuler le résultat). Dans ce cas, nous créons une variable distincte pour chaque affectation.

4. Simplifying Conditional Expressions (Simplification des expressions avec conditions) :

   • Decompose Conditional (Décomposition de l'opérateur conditionnel) – exécuté lorsque nous avons une chaîne conditionnelle de contrôles (if-then-else). Nous remplaçons la condition (if), des parties de then et else par des méthodes distinctes. Contribuer à une meilleure compréhension de la raison du branchement et des noms de méthodes clarifiant l’objectif du morceau de code correspondant.
   • Consolidate Conditional Expression (Consolidation de l'expression conditionnelle) - est effectuer s'il existe plusieurs contrôles d'état donnant le même résultat. Vous devez combiner toutes les vérifications en une seule expression ou méthode conditionnelle.
   • Consolidate Duplicate Conditional Fragments (Consolidation de fragments en double conditionnels) – le même fragment est présent dans toutes les branches de l'expression conditionnelle. Vous devez déplacer ce morceau de code en dehors de cette expression.
   • Remove Control Flag (Suppression du drapeau de contrôle) – il existe une variable qui agit comme un indicateur de contrôle pour une série d'expressions logiques. Nous utilisons plutôt BREAK ou RETURN.
   • Replace Conditional with Polymorphism (Remplacement de l'opérateur conditionnel par le polymorphisme) – est effectuer lorsqu'il existe un opérateur conditionnel dont le comportement dépend du type d'objet. Il faut déplacer chaque branche de l'opérateur conditionnel dans une méthode suralimentée de la sous-classe. Rendre le code source abstrait.