# Amélioration et refactorisation du code (/fr/docs/verdent-for-vscode/task-based-guides/refactoring)
> Bonnes pratiques pour l'amélioration du code et la refactorisation avec Verdent
Verdent for VS Code vous aide à refactoriser et à améliorer le code en toute sécurité sur plusieurs fichiers tout en préservant les fonctionnalités. En utilisant Plan Mode avec le sous-agent Explorer, vous pouvez identifier tous les fichiers concernés avant d'effectuer des modifications, garantissant une refactorisation complète sans oublier aucune occurrence.
### Ce que vous allez apprendre [#ce-que-vous-allez-apprendre]
* Demander des refactorisations efficaces axées sur les résultats, et non sur l'implémentation
* Refactoriser en toute sécurité sur plusieurs fichiers avec gestion des dépendances
* Demander des améliorations de la qualité du code et des suggestions d'optimisation
* Gérer des projets de refactorisation à grande échelle avec des approches multi-phases
* Optimiser les performances grâce à des améliorations algorithmiques et architecturales
* Préserver les fonctionnalités du code pendant les opérations de refactorisation
### Prérequis [#prérequis]
Avant de refactoriser avec Verdent :
* Visual Studio Code avec l'extension Verdent installée
* Une base de code ou un espace de travail de projet ouvert dans VS Code
* Un abonnement Verdent actif avec des crédits disponibles
* Un contrôle de version (Git) recommandé pour un retour en arrière sûr si nécessaire
***
## Demander des refactorisations efficaces [#demander-des-refactorisations-efficaces]
Décrivez **ce que vous voulez améliorer et pourquoi**, plutôt que **comment le corriger**. Laissez Verdent analyser le code et proposer la meilleure approche en fonction des schémas de votre projet.
**Demandes de refactorisation efficaces :**
Concentrez-vous sur le résultat souhaité, pas sur l'implémentation :
```
Refactor the UserController to improve readability and reduce duplication
```
```
This authentication logic is scattered across multiple files. Consolidate it into a single module
```
```
Improve error handling in the API layer to be more consistent and informative
```
Verdent analyse le code, identifie tous les fichiers concernés, examine les schémas et propose des stratégies de refactorisation spécifiques alignées sur les conventions de votre base de code.
**Bonne pratique : utilisez Plan Mode**
Commencez les demandes de refactorisation dans Plan Mode. Verdent va :
1. Analyser le code et identifier tous les fichiers concernés
2. Présenter un plan de refactorisation détaillé avant d'effectuer des modifications
3. Poser des questions de clarification sur les préférences d'implémentation
4. Montrer exactement ce qui va changer et dans quel ordre
5. Vous permettre de revoir et d'affiner l'approche
**Exemple avec Plan Mode :**
```
In Plan Mode: Refactor authentication logic to use a centralized authentication utility
```
Verdent va :
* Utiliser Explorer pour trouver tous les emplacements du code d'authentification
* Identifier les schémas et les incohérences
* Proposer une interface d'authentification unifiée
* Montrer quels fichiers seront modifiés
* Expliquer la séquence de refactorisation
Vous pouvez demander à Verdent d'enregistrer le plan dans un fichier `plan.md` pour une révision supplémentaire et une discussion en équipe avant l'exécution.
**Utiliser Explorer pour des recherches exhaustives :**
Pour les refactorisations complexes, demandez explicitement à Verdent d'utiliser l'agent Explorer pour effectuer une recherche approfondie :
```
Use the Explorer agent to find all places where we manually validate email addresses, then refactor them to use a centralized validation utility
```
Cela garantit que Verdent découvre tous les emplacements à mettre à jour, évitant une refactorisation incohérente dans la base de code.
Plan Mode est essentiel pour la refactorisation. Il évite les surprises en montrant exactement ce qui va changer avant l'exécution, et vous permet d'affiner l'approche en fonction de considérations architecturales.
***
## Refactorisation multi-fichiers [#refactorisation-multi-fichiers]
Verdent refactorise sur plusieurs fichiers tout en maintenant les imports, les dépendances et les références inter-fichiers. Il identifie tous les fichiers concernés, les met à jour dans le bon ordre et garantit la cohérence dans l'ensemble de la base de code.
**Comment fonctionne la refactorisation multi-fichiers :**
1. **Phase de découverte** : Verdent (à l'aide d'Explorer) trouve tous les fichiers nécessitant des modifications
2. **Analyse des dépendances** : identifie les dépendances entre les fichiers pour déterminer l'ordre de mise à jour
3. **Création du plan** : montre tous les fichiers à modifier et la séquence des modifications
4. **Mises à jour séquentielles** : modifie les fichiers dans l'ordre des dépendances (par exemple, les types avant les composants qui les utilisent)
5. **Gestion des imports** : met automatiquement à jour les imports, les exports et les références inter-fichiers
6. **Vérification** : vérifie que les modifications sont cohérentes dans tous les fichiers
La refactorisation multi-fichiers préserve les fonctionnalités grâce à un suivi automatisé des dépendances, Verdent met à jour tous les fichiers concernés de manière atomique.
**Exemple :**
```
Rename the User interface to UserProfile across the entire project
```
Verdent va :
* Trouver tous les fichiers qui importent ou utilisent `User`
* Identifier les définitions de types, les implémentations et les utilisations
* Mettre à jour d'abord les définitions de types, puis les implémentations, puis les utilisations
* Ajuster toutes les instructions d'import
* Garantir la cohérence dans l'ensemble de la base de code
**Utilisez Plan Mode pour examiner la portée :**
Avant d'exécuter une refactorisation multi-fichiers, examinez la portée complète dans Plan Mode :
```
In Plan Mode: Extract the authentication logic from UserController into a separate AuthService
```
Verdent va montrer :
* Quels fichiers seront créés (nouveau AuthService)
* Quels fichiers seront modifiés (UserController et tous les fichiers qui l'importent)
* Quel code sera déplacé de UserController vers AuthService
* Comment les imports et les dépendances seront mis à jour
Cela évite une dérive accidentelle de la portée et vous garantit de comprendre l'impact complet avant de continuer.
***
## Demander des améliorations de la qualité du code [#demander-des-améliorations-de-la-qualité-du-code]
Verdent ne suggère pas proactivement des améliorations sans y être invité. Cependant, vous pouvez demander des revues de qualité du code et des suggestions d'amélioration à tout moment.
Demandez des revues générales de qualité du code :
```
Review this code for potential improvements
```
```
Suggest ways to improve code quality in the UserService module
```
```
Are there any performance optimizations we could make here?
```
```
Analyze the PaymentController for maintainability issues
```
Verdent analyse le code et fournit des suggestions précises concernant :
* **Lisibilité** : nommage des variables, décomposition des fonctions, clarté des commentaires
* **Performance** : complexité algorithmique, opérations redondantes, opportunités de mise en cache
* **Maintenabilité** : duplication de code, couplage, séparation des responsabilités
* **Bonnes pratiques** : modèles de conception, gestion des erreurs, couverture des tests
* **Sécurité** : validation des entrées, contrôles d'authentification, exposition des données
Pour un retour ciblé, référencez des fichiers spécifiques :
```
@services/UserService.js Review this module for dependency injection improvements
```
```
@controllers/PaymentController.js Identify opportunities to reduce complexity
```
Verdent examine le code spécifié dans le contexte des schémas de votre projet et fournit des recommandations exploitables.
***
## Projets de refactorisation à grande échelle [#projets-de-refactorisation-à-grande-échelle]
Pour la refactorisation à grande échelle, utilisez Plan Mode avec une **approche multi-phases** pour obtenir les résultats les plus fiables. Verdent décompose la refactorisation en étapes gérables, vous permettant de revoir et d'approuver chaque phase avant de continuer.
**Flux de travail de refactorisation multi-phases :**
#### Phase 1 : analyse initiale [#phase-1--analyse-initiale]
Utilisez Plan Mode avec l'agent Explorer pour identifier tous les fichiers et dépendances concernés :
```
In Plan Mode: Use Explorer to analyze our codebase and create a plan to replace our custom authentication with OAuth 2.0
```
Verdent effectue une analyse complète :
* Identifie tout le code lié à l'authentification
* Cartographie les dépendances et les points d'intégration
* Évalue la complexité et les zones à risque
* Propose une répartition en phases
#### Phase 2 : planification des phases [#phase-2--planification-des-phases]
Verdent crée un plan multi-phases pour révision :
**Exemple de plan :**
* **Phase 1** : ajouter la bibliothèque OAuth et configurer les points de terminaison
* **Phase 2** : mettre à jour le modèle utilisateur et le schéma de base de données
* **Phase 3** : migrer la logique d'authentification existante
* **Phase 4** : supprimer le code d'authentification obsolète
* **Phase 5** : mettre à jour les tests et la documentation
Chaque phase comprend :
* Les fichiers à modifier
* La complexité estimée
* Les dépendances vis-à-vis des phases précédentes
* L'évaluation des risques
#### Phase 3 : exécution phase par phase [#phase-3--exécution-phase-par-phase]
Exécutez une phase à la fois, en testant entre les phases :
1. Approuvez la phase 1 dans Plan Mode
2. Passez en Agent Mode et exécutez
3. Testez soigneusement pour vérifier que la phase 1 fonctionne
4. Retournez en Plan Mode pour la phase 2
5. Répétez jusqu'à ce que toutes les phases soient terminées
#### Phase 4 : affinement itératif [#phase-4--affinement-itératif]
Passez en revue les résultats après chaque phase. Si des problèmes surviennent :
* Ajustez le plan pour les phases restantes
* Ajoutez des phases correctives si nécessaire
* Affinez l'approche en fonction des découvertes
Cette approche par phases garantit la sécurité et permet une correction de trajectoire en cas de problème lors de grands projets de refactorisation.
La refactorisation à grande échelle doit toujours être effectuée avec un contrôle de version. Validez après chaque phase afin de pouvoir revenir en arrière si des problèmes surviennent, sans perdre toute la progression.
***
## Optimisation des performances [#optimisation-des-performances]
Verdent analyse le code à la recherche de goulots d'étranglement de performance et suggère des optimisations, notamment des améliorations de la complexité algorithmique, des structures de données efficaces et une réduction de l'utilisation des ressources.
Améliorez la complexité algorithmique :
```
Analyze the performance of this data processing function and suggest improvements
```
```
Can we improve the time complexity of this search algorithm?
```
**Ce que Verdent identifie :**
* **Complexité algorithmique** : boucles O(n²), itérations imbriquées, recherches inefficaces
* **Calculs redondants** : calculs répétés, opérations inutiles
* **Problèmes de mémoire** : fuites de mémoire, allocations excessives, rétention d'objets volumineux
**Exemple :**
```
Optimize the searchProducts function that's currently O(n²)
```
Verdent analyse la fonction, identifie l'inefficacité (boucles imbriquées ou recherches linéaires répétées) et propose des améliorations précises :
* Remplacer la boucle imbriquée par une table de hachage pour une recherche en O(n)
* Utiliser une recherche binaire après tri pour une complexité en O(log n)
* Mettre en cache les résultats calculés pour éviter les calculs redondants
* Mettre en œuvre la mémoïsation pour les opérations coûteuses
La réponse comprend :
* **Complexité actuelle** : explication des raisons pour lesquelles le code actuel est lent
* **Solution proposée** : modification précise de l'algorithme ou de la structure de données
* **Gain de performance** : amélioration estimée (par exemple, O(n²) → O(n log n))
* **Compromis** : considérations sur l'utilisation de la mémoire, la complexité du code et la maintenabilité
Optimisez les composants d'interface utilisateur et le rendu :
```
Optimize this component to reduce unnecessary re-renders
```
**Ce que Verdent identifie :**
* **Performance front-end** : re-rendus inutiles, tailles de bundle importantes, opérations bloquantes
* **Cycle de vie des composants** : dépendances useEffect inefficaces, mémoïsation manquante
* **Gestion d'état** : mises à jour d'état redondantes, prop drilling
Verdent analyse votre composant et suggère des optimisations telles que React.memo, useMemo, useCallback ou la division de composants.
Identifiez et corrigez les goulots d'étranglement liés à API et à la base de données :
```
Identify performance bottlenecks in the API request handler
```
**Ce que Verdent identifie :**
* **Performance de la base de données** : requêtes N+1, index manquants, jointures inefficaces
* **Performance API** : points de terminaison lents, récupération de données inefficace, mise en cache manquante
Verdent examine les schémas de requêtes, suggère des index de base de données, des stratégies de mise en cache et des techniques d'optimisation API.
Pour l'optimisation des performances, fournissez du contexte sur les tailles de données typiques et les contraintes de performance. Cela aide Verdent à proposer des solutions adaptées à votre échelle (par exemple, 100 éléments contre 1 million d'éléments).
Effectuez un profilage avant d'optimiser, mesurez l'impact sur les performances pour vous assurer que les optimisations apportent des améliorations significatives.
***
## Préserver les fonctionnalités pendant la refactorisation [#préserver-les-fonctionnalités-pendant-la-refactorisation]
Verdent vise à préserver les fonctionnalités du code pendant la refactorisation en maintenant les mêmes entrées, sorties et comportements tout en améliorant l'implémentation interne.
**Comment Verdent préserve les fonctionnalités :**
* **Analyse des entrées/sorties** : identifie les signatures de fonctions, les contrats API et les comportements attendus
* **Prise en compte des tests** : considère les tests existants comme des spécifications comportementales
* **Modifications prudentes** : effectue des modifications minimales pour atteindre l'objectif de refactorisation
* **Vérification** : peut générer ou exécuter des tests pour vérifier que les fonctionnalités sont préservées
**Bonnes pratiques pour une refactorisation sûre :**
1. **Testez toujours le code refactorisé** - Même avec l'analyse de Verdent, des tests manuels ou automatisés permettent de vérifier que les fonctionnalités sont préservées, en particulier pour les refactorisations complexes
2. **Utilisez le contrôle de version** - Validez avant la refactorisation afin de pouvoir revenir en arrière en cas de problème
3. **Refactorisez progressivement** - Décomposez les grandes refactorisations en étapes plus petites, en testant après chaque modification
4. **Examinez les modifications avec attention** - Examinez le diff pour comprendre ce qui a changé et pourquoi
5. **Utilisez Plan Mode pour les refactorisations complexes** - Revoyez l'approche avant l'exécution pour détecter les problèmes potentiels
**Exemple : demande de refactorisation sûre**
```
Refactor the calculateOrderTotal function to use a more maintainable structure, but ensure it produces identical results for all input cases
```
Verdent va :
* Analyser l'implémentation actuelle et les cas particuliers
* Proposer une structure refactorisée
* Expliquer pourquoi la version refactorisée est équivalente
* Suggérer des cas de test pour vérifier l'équivalence
**Quand les fonctionnalités peuvent changer :**
Dans certains cas, la refactorisation modifie intentionnellement le comportement (correction de bugs, amélioration de la validation). Rendez cela explicite :
```
Refactor the email validation function to correctly handle international domains, which the current implementation doesn't support
```
Cela indique que le changement de comportement est attendu et intentionnel.
***
## Bonnes pratiques [#bonnes-pratiques]
Laissez Verdent analyser le code et proposer la meilleure approche de refactorisation plutôt que de prescrire des modifications précises.
Passez en revue le plan complet avant l'exécution. Cela évite les surprises et vous permet d'affiner l'approche en fonction de considérations architecturales.
Pour une refactorisation approfondie, demandez à Verdent d'utiliser Explorer pour trouver toutes les occurrences : « Utilise Explorer pour trouver toute la gestion manuelle des erreurs, puis refactorise pour utiliser notre utilitaire d'erreurs. »
Les approches multi-phases avec des tests entre les phases sont plus sûres et plus faciles à gérer que de tout tenter en une seule fois.
Vérifiez que chaque phase fonctionne avant de passer à la suivante. Cela isole les problèmes et évite qu'ils ne s'accumulent.
Utilisez le contrôle de version pour créer des points de contrôle après chaque phase ou modification majeure. Cela permet un retour en arrière sûr sans perdre toute la progression.
Pour les refactorisations importantes, demandez à Verdent d'enregistrer le plan dans `plan.md` pour une discussion en équipe avant l'exécution.
Lors d'une demande d'amélioration des performances, incluez des informations sur les tailles de données, les contraintes de performance et les compromis acceptables.
***
## Voir aussi [#voir-aussi]
Générez des tests pour vérifier que le code refactorisé fonctionne correctement
Analysez la structure du code avant la refactorisation pour comprendre l'impact