En tant que développeur, comment commencer à travailler sur un nouveau projet… ??

Tout d’abord, vous rassemblez quelques exigences de base, puis, en fonction de ces exigences, vous commencez à implémenter les fonctionnalités une par une. Au fur et à mesure que vous progressez dans votre projet et que vous en apprenez davantage, vous continuez à ajouter et à modifier le code dans votre base de code. Plus tard, vous modifiez également le code pour corriger les bogues et les cas extrêmes.

Mais que se passe-t-il après quelques jours ou quelques mois… ? À quoi ressemble votre code… ?? Est-ce compliqué ? Est-ce difficile à comprendre ? Si oui, alors vous n’avez certainement pas prêté attention à l’amélioration de votre code ou à la restructuration de votre code. Vous avez peut-être écrit du code en double sans examiner le code existant ou vous avez peut-être écrit des méthodes/fonctions plus longues, des classes volumineuses, trop de paramètres, des noms de variables non intuitifs, le placement du code, etc.

L'amélioration ou la mise à jour du code sans modifier les fonctionnalités du logiciel ou le comportement externe de l'application est appelée refactorisation de code. Cela réduit le coût technique et rend le code plus efficace et plus maintenable. Si vous ne prêtez pas attention au processus de refactorisation du code plus tôt, vous paierez plus tard pour les erreurs dans votre code. Alors n’ignorez pas le nettoyage du code.

Dans un processus de développement logiciel, différents développeurs ont des styles d'écriture de code différents. Ils apportent des modifications, maintiennent le code, étendent le code et la plupart du temps, ils quittent le code sans refactorisation continue. Le code non refactorisé a tendance à pourriture du code : beaucoup de confusion et d'encombrement dans le code tel que du code en double, des dépendances malsaines entre classes ou packages, une mauvaise allocation des responsabilités de classe, trop de responsabilités par méthode ou classe, etc. Pour éviter tous ces problèmes, une refactorisation continue est importante.

Maintenant, la question est… quelles sont les techniques pour refactoriser le code ?

Nous discuterons de quelques techniques populaires et courantes pour refactoriser le code, mais avant cela, discutons de quelques conseils rapides…

Conseils:

• Vous devez effectuer une refactorisation du code par petites étapes. Apportez de petites modifications à votre programme, chacune des petites modifications améliore légèrement votre code et laisse l'application en état de fonctionnement.
• Exécutez les tests TDD et CI après avoir apporté de petites modifications dans le processus de refactoring. Sans exécuter ces tests, vous risquez d’introduire des bugs.
• Ne créez aucune nouvelle fonctionnalité ou fonctionnalité pendant le processus de refactoring. Vous devez refactoriser le code avant d'ajouter des mises à jour ou de nouvelles fonctionnalités dans votre code existant.
• Le processus de refactoring peut affecter les résultats des tests, il est donc bon d'impliquer votre équipe d'assurance qualité et de test dans le processus de refactoring.
• Vous devez accepter que vous ne serez pas entièrement satisfait de votre code. Votre code refactorisé sera obsolète dans un avenir proche et vous devrez le refactoriser à nouveau.

Techniques de refactorisation de code les plus courantes

Il existe de nombreuses approches et techniques pour refactoriser le code. Discutons de quelques-uns des plus populaires…

1. Refactorisation rouge-vert

Le rouge-vert est la technique de refactorisation de code la plus populaire et la plus utilisée dans le processus de développement logiciel Agile. Cette technique suit l'approche de conception et de mise en œuvre axée sur le test, ce qui pose les bases de toutes les formes de refactoring. Les développeurs prennent l'initiative de la refactorisation dans le cycle de développement piloté par les tests et elle est effectuée en trois étapes de district.

• ROUGE: La première étape commence par l’écriture du test rouge défaillant. Vous vous arrêtez et vérifiez ce qui doit être développé.
• Vert: Dans la deuxième étape, vous écrivez le code le plus simple et obtenez les tests verts de réussite du développement.
• Refactoriser : Dans les dernières et troisièmes étapes, vous vous concentrez sur l'amélioration et l'amélioration de votre code en gardant votre test vert.

Donc, fondamentalement, cette technique comporte deux parties distinctes : la première partie consiste à écrire du code qui ajoute une nouvelle fonction à votre système et la deuxième partie consiste à refactoriser le code qui remplit cette fonction. Gardez à l’esprit que vous n’êtes pas censé faire les deux en même temps pendant le flux de travail.

2. Refactorisation par abstraction

Cette technique est principalement utilisée par les développeurs lorsqu’il est nécessaire d’effectuer une grande quantité de refactoring. Nous utilisons principalement cette technique pour réduire la redondance (duplication) dans notre code. Cela implique les héritages de classes, la hiérarchie, la création de nouvelles classes et interfaces, l'extraction, le remplacement de l'héritage par la délégation, et vice versa.

Pull-Up/Push-Down La méthode est le meilleur exemple de cette approche.

• Méthode Pull-Up : Il extrait des parties de code dans une superclasse et contribue à éliminer la duplication de code.
• Méthode Push-Down : Il prend la partie code d'une superclasse et la déplace jusque dans les sous-classes.

Extrayez le corps du constructeur, extrayez la sous-classe, extrayez la superclasse, réduisez la hiérarchie, la méthode du modèle de formulaire, extrayez l'interface, remplacez l'héritage par la délégation, remplacez la délégation par l'héritage, poussez le champ vers le bas, ce sont tous les autres exemples.

Fondamentalement, dans cette technique, nous construisons la couche d'abstraction pour les parties du système qui doivent être refactorisées et la contrepartie qui finira par la remplacer. Deux exemples courants sont donnés ci-dessous…

abstraction en java

• Encapsulé champ: Nous forçons le code à accéder au champ avec les méthodes getter et setter.
• Type généralisé : Nous créons des types plus généraux pour permettre le partage de code, remplaçons le code de vérification de type par l'état, remplaçons le conditionnel par le polymorphisme, etc.

3. Méthode de composition

Pendant la phase de développement d’une application, nous écrivons souvent de longues méthodes dans notre programme. Ces méthodes longues rendent votre code extrêmement difficile à comprendre et difficile à modifier. La méthode de composition est principalement utilisée dans ces cas.

Dans cette approche, nous utilisons des méthodes rationalisées pour réduire la duplication dans notre code. Quelques exemples sont : extraire la méthode, extraire une variable, Inline Temp, remplacer Temp par Query, méthode en ligne, diviser la variable temporaire, supprimer les affectations aux paramètres, etc.

Extraction: Nous divisons le code en morceaux plus petits pour rechercher et extraire la fragmentation. Après cela, nous créons des méthodes distinctes pour ces morceaux, puis elles sont remplacées par un appel à cette nouvelle méthode. L'extraction implique des variables de classe, d'interface et locales.

En ligne: Cette approche supprime le nombre de méthodes inutiles dans notre programme. Nous trouvons tous les appels aux méthodes, puis nous les remplaçons tous par le contenu de la méthode. Après cela, nous supprimons la méthode de notre programme.

programme java

4. Simplifier les méthodes

Il existe deux techniques impliquées dans cette approche… discutons des deux.

• Simplification de la refactorisation des expressions conditionnelles : Instruction conditionnelle en programmation devient plus logique et compliqué avec le temps. Vous devez simplifier la logique de votre code pour comprendre l'ensemble du programme.
  Il existe de nombreuses façons de refactoriser le code et de simplifier la logique. Certains d'entre eux sont : consolider l'expression conditionnelle et dupliquer des fragments conditionnels, décomposer le conditionnel, remplacer le conditionnel par un polymorphisme, supprimer l'indicateur de contrôle, remplacer le conditionnel imbriqué par des clauses de garde, etc.
• Refactorisation simplifiée des appels de méthode : Dans cette approche, nous rendons les appels de méthode plus simples et plus faciles à comprendre. Nous travaillons sur l'interaction entre les classes, et nous simplifions leurs interfaces.
  Exemples : ajouter, supprimer et introduire de nouveaux paramètres, remplacer le paramètre par la méthode explicite et l'appel de méthode, paramétrer la méthode, créer une requête distincte du modificateur, conserver l'objet entier, supprimer la méthode de définition, etc.

5. Déplacement de fonctionnalités entre des objets

Dans cette technique, nous créons de nouvelles classes et déplaçons les fonctionnalités en toute sécurité entre les anciennes et les nouvelles classes. Nous cachons les détails de mise en œuvre à l'accès public.

Maintenant, la question est… quand déplacer les fonctionnalités entre les classes ou comment identifier qu’il est temps de déplacer les fonctionnalités entre les classes ?

Lorsque vous constatez qu'une classe a tellement de responsabilités et qu'il se passe trop de choses ou lorsque vous trouvez qu'une classe est inutile et ne fait rien dans une application, vous pouvez déplacer le code de cette classe vers une autre classe et le supprimer complètement.

Exemples : déplacer un champ, extraire une classe, déplacer une méthode, une classe en ligne, masquer un délégué, introduire une méthode étrangère, supprimer un intermédiaire, introduire une extension locale, etc.

6. Refactorisation préparatoire

Il est préférable d'utiliser cette approche lorsque vous remarquez la nécessité d'une refactorisation lors de l'ajout de nouvelles fonctionnalités dans une application. Donc, fondamentalement, cela fait partie d’une mise à jour logicielle avec un processus de refactorisation distinct. Vous vous épargnez une dette technique future si vous remarquez que le code doit être mis à jour au cours des premières phases de développement des fonctionnalités.

L'utilisateur final ne peut pas être d'accord sur les efforts de l'équipe d'ingénierie, mais les développeurs travaillant sur l'application trouveront l'intérêt de refactoriser le code lors de la création de l'application. Ils peuvent économiser du temps, de l’argent et d’autres ressources s’ils passent simplement un peu de temps à mettre à jour le code plus tôt.

C'est comme si je voulais parcourir 100 milles à l'est, mais au lieu de simplement me promener à travers les bois, je vais conduire 20 milles au nord jusqu'à l'autoroute, puis je vais parcourir 100 milles à l'est à trois fois la vitesse que j'aurais pu avoir si Je suis juste allé directement là-bas. Lorsque les gens vous poussent à y aller directement, vous devez parfois dire : « Attendez, je dois vérifier la carte et trouver l'itinéraire le plus rapide. » La refactorisation préparatoire fait cela pour moi.

Jessica Kerr (Développeur de logiciels)

7. Refactorisation de l'interface utilisateur

Vous pouvez apporter des modifications simples à l'interface utilisateur et refactoriser le code. Par exemple : aligner le champ de saisie, appliquer la police, reformuler à la voix active, indiquer le format, appliquer la taille commune des boutons et augmenter le contraste des couleurs, etc.

Derniers mots

Vous devez considérer le processus de refactorisation du code comme un nettoyage de la maison des ordonnés. Un encombrement inutile dans une maison peut créer un environnement chaotique et stressant. Il en va de même pour le code écrit. Un code propre et bien organisé est toujours facile à modifier, à comprendre et à maintenir. Vous ne rencontrerez pas de difficultés plus tard si vous prêtez attention au processus de refactorisation du code plus tôt.

Deux des développeurs de logiciels les plus influents Martin Fowler et Kent Beck ont consacré leur temps à expliquer le processus de refactorisation du code et ses techniques. Ils ont également écrit un livre complet sur ce sujet Refactoring : améliorer la conception du code existant . Ce livre décrit diverses techniques de refactoring avec une explication claire du travail sur ces processus de refactoring. Nous vous recommandons de lire ce livre si vous souhaitez approfondir le processus de refactorisation du code.