CHAPITRE 01 Refactorisation : Le premier exemple
1.1 Ok, commençons !
1.2 Impressions après avoir vu le programme d'exemple
1.3 La première étape de la refactorisation
1.4 Division de la fonction statement()
1.5 Révision de mi-session : Surcharge de fonctions imbriquées
1.6 Séparation des étapes de calcul et de mise en forme
1.7 Vérification intermédiaire : Diviser en deux fichiers (et deux étapes)
1.8 Restructuration du code informatique à l'aide du polymorphisme
1.9 Vérification d'état : Génération de données à l'aide du polymorphisme
1.10 En conclusion

CHAPITRE 02 Principes de refactorisation
2.1 Définition du refactoring
2.2 Deux chapeaux
2.3 Raisons de la refactorisation
2.4 Quand faut-il refactoriser ?
2.5 Points à prendre en compte lors de la refactorisation
2.6 Refactorisation, architecture et YAGNI
2.7 Refactorisation et processus de développement logiciel
2.8 Refactorisation et performances
2.9 Origines du refactoring
2.10 Automatisation de la refactorisation
2.11 Si vous souhaitez en savoir plus

CHAPITRE 03 L'odeur du code
3.1 Noms étranges
3.2 Code dupliqué
3.3 Fonctions longues
3.4 Liste des paramètres longs
3.5 Données mondiales
3.6 Données variables
3.7 Changements complexes
3.8 Chirurgie au fusil de chasse
3.9 Préférences de fonctionnalités
3.10 Forfaits de données
3.11 Obsession fondamentale
3.12 Instructions switch répétées
3.13 Boucles
3.14 Éléments insincères
3.15 Généralisation spéculative
3.16 Champs temporaires
3.17 Chaîne de messages
3.18 Courtier
3.19 Délit d'initié
Classe 3.20 Énorme
3.21 Classes alternatives pour différentes interfaces
3.22 Classes de données
3.23 Renonciation à l'héritage
3.24 Commentaire

CHAPITRE 04 Tests de construction
4.1 L'intérêt du code autotesté
4.2 Exemple de code à tester
4.3 Premier test
4.4 Ajout de tests
4.5 Modification du dispositif
4.6 Vérification des conditions aux limites
4.7 Le voyage inachevé

CHAPITRE 05 : Comment consulter le catalogue de refactorisation
5.1 Format de description de la refactorisation
5.2 Critères de sélection des techniques de refactorisation

CHAPITRE 06 Refactorisation de base
6.1 Extraction de fonctions
6.2 Fonctions d'intégration
6.3 Extraction des variables
6.4 Variables en ligne
6.5 Modification des déclarations de fonctions
6.6 Variables d'encapsulation
6.7 Renommer les variables
6.8 Création d'un objet paramètre
6.9 Regroupement de plusieurs fonctions dans une classe
6.10 Combinaison de plusieurs fonctions en une fonction de transformation
6.11 Division des étapes

CHAPITRE 07 Encapsulation
7.1 Enregistrements encapsulés
7.2 Collections encapsulées
7.3 Conversion des primitives en objets
7.4 Conversion des variables temporaires en fonctions de requête
7.5 Extraction des classes
7.6 Intégration d'une classe
7.7 Masquer la délégation
7.8 Suppression de l'intermédiaire
7.9 Remplacement de l'algorithme

CHAPITRE 08 Mouvement fonctionnel
8.1 Fonctions de déplacement
8.2 Champs mobiles
8.3 Transformer les phrases en fonctions
8.4 Déplacez les phrases à l'endroit où elles étaient appelées
8.5 Conversion de code en ligne en appels de fonction
8.6 Diapositive de phrase
8.7 Division des boucles
8.8 Conversion d'une boucle en pipeline
8.9 Suppression du code mort

CHAPITRE 09 Organisation des données
9.1 Fractionnement des variables
9.2 Renommage des champs
9.3 Conversion des variables dérivées en fonctions de requête
9.4 Conversion des références en valeurs
9.5 Conversion des valeurs en références
9.6 Modification des littéraux magiques

CHAPITRE 10 Simplification de la logique conditionnelle
10.1 Décomposition des instructions conditionnelles
10.2 Intégration des expressions conditionnelles
10.3 Conversion des instructions conditionnelles imbriquées en instructions protégées
10.4 Conversion de la logique conditionnelle en polymorphisme
10.5 Ajout de cas particuliers
10.6 Ajout d'une assertion
10.7 Modifier les indicateurs de contrôle des trappes d'évacuation

CHAPITRE 11 Refactorisation d'API
11.1 Séparation des fonctions de requête et de modification
11.2 Paramétrage des fonctions
11.3 Suppression des arguments de drapeau
11.4 Passage d'un objet entier
11.5 Conversion des paramètres en fonctions de requête
11.6 Conversion d'une fonction de requête en paramètre
11.7 Retrait du setter
11.8 Remplacement des constructeurs par des fonctions de fabrique
11.9 Conversion des fonctions en commandes
11.10 Conversion des commandes en fonctions
11.11 Retour des valeurs modifiées
11.12 Conversion des codes d'erreur en exceptions
11.13 Modifier les exceptions en pré-vérifications

CHAPITRE 12 LA GÉRER L'HÉRITAGE
12.1 Méthodes de téléchargement
12.2 Élever le terrain
12.3 Téléchargement du corps du constructeur
12.4 Méthode vers le bas
12,5 Terrain en baisse
12.6 Conversion des codes de type en sous-classes
12.7 Suppression d'une sous-classe
12.8 Extraction des superclasses
12.9 Fusion de calques
12.10 Conversion d'une sous-classe en délégué
12.11 Conversion d'une superclasse en délégué

Annexe A : Liste des refactorisations
Annexe B Techniques d'élimination des odeurs

L'ouvrage « Refactoring » de Martin Fowler, deuxième édition, fait son grand retour après 20 ans d'absence.
La première édition de Refactoring a été publiée en 1999, et l'édition coréenne a été introduite en Corée en 2002.
Il a été plébiscité par d'innombrables lecteurs et a contribué à populariser le terme de refactoring dans le monde de la programmation.

Qu’est-ce qui a changé dans le refactoring 18 ans après la publication de la première édition ? Bien que presque chaque page de cette deuxième édition ait été réécrite, le cœur du refactoring reste inchangé et les techniques clés de refactoring demeurent pertinentes.
La deuxième édition servira de catalyseur pour permettre à davantage de personnes d'apprendre à refactoriser efficacement.


Qu'est-ce que le refactoring ?
La refactorisation est le processus de modification d'un système logiciel de manière à améliorer sa structure interne sans modifier la fonctionnalité externe du code.
En bref, la refactorisation est le processus d'amélioration de la conception du code après son écriture.

Contenu couvert
Ce livre est un guide de refactoring écrit pour les programmeurs professionnels.
L'objectif est de vous apprendre à refactoriser de manière disciplinée et efficace.
Explique comment modifier la structure de manière plus systématique sans introduire de bogues dans le code.

À qui s'adresse-t-il ?
Ce livre est destiné aux programmeurs professionnels dont le métier est le développement logiciel.
Les exemples et le texte contiennent pas mal de code à lire et à comprendre.
Tous les exemples de code sont écrits en JavaScript, mais devraient être applicables à la plupart des langages.
Une certaine expérience en programmation est recommandée pour suivre le contenu de ce livre, mais il peut être lu même par des non-experts.

Changements de style de codage
Ce n'est pas parce que vous avez appris la grammaire d'un langage orienté objet que vous pouvez automatiquement faire de la programmation orientée objet.
Le catalogue de refactorisation vous aide à comprendre quel code doit être corrigé, pourquoi il doit l'être et pourquoi le code corrigé est une bonne chose.
Ce processus vous permettra d'apprendre une conception de code adaptée à l'orientation objet, et votre propre style de programmation évoluera également.
Vous constaterez une différence significative dans la qualité de votre code avant et après la lecture de ce livre.


Contenu principal
Comprendre le processus de refactorisation et les principes généraux
• Appliquez rapidement des refactorisations utiles qui rendent les programmes plus faciles à comprendre et à modifier.
Identifier les anomalies dans le code qui pourraient être remaniées.
• Examinez les concepts, les motivations, la dynamique et des exemples simples de chaque technique de refactorisation.
• Création de tests robustes permettant la refactorisation
Identifier les avantages, les inconvénients et les obstacles de la refactorisation.