{"meta":{"title":"Augmentation du score de qualité du code de votre référentiel","intro":"Hiérarchiser et résoudre les résultats qui présentent le plus de risques, augmenter le score de qualité du code de votre dépôt et empêcher l’accumulation de nouvelles dettes.","product":"Sécurité et qualité du code","breadcrumbs":[{"href":"/fr/enterprise-cloud@latest/code-security","title":"Sécurité et qualité du code"},{"href":"/fr/enterprise-cloud@latest/code-security/tutorials","title":"Tutorials"},{"href":"/fr/enterprise-cloud@latest/code-security/tutorials/improve-code-quality","title":"Améliorer la qualité du code"},{"href":"/fr/enterprise-cloud@latest/code-security/tutorials/improve-code-quality/raise-your-quality-rating","title":"Augmenter votre score de qualité"}],"documentType":"article"},"body":"# Augmentation du score de qualité du code de votre référentiel\n\nHiérarchiser et résoudre les résultats qui présentent le plus de risques, augmenter le score de qualité du code de votre dépôt et empêcher l’accumulation de nouvelles dettes.\n\n## Présentation\n\nDans ce tutoriel, vous allez travailler sur un backlog de Code Quality résultats sur votre branche par défaut, hiérarchiser par risque, résoudre les résultats les plus impactants et communiquer le résultat aux parties prenantes. Vous apprendrez ce qui suit :\n\n* Comment lire le tableau de bord et comprendre ce que signifient vos scores.\n* Comment hiérarchiser la correction et décider s’il faut appliquer un correctif automatique, déléguer à Copilot cloud agentou ignorer une recherche.\n* Comment communiquer l’impact du travail de correction.\n* Quelles mesures supplémentaires vous pouvez prendre pour empêcher le backlog de croître à nouveau.\n\nIl s’agit d’un parcours guidé, qui privilégie la compréhension plutôt que la rapidité. Pour les étapes de base permettant de créer un correctif automatique ou de rejeter un résultat, consultez le guide pratique associé : [Correction des problèmes de qualité du code dans le backlog de votre dépôt](/fr/enterprise-cloud@latest/code-security/how-tos/maintain-quality-code/fix-backlog-findings).\n\n### Avant de commencer\n\n* Code Quality est activé sur un référentiel que vous possédez ou gérez. Consultez « [Activation de GitHub Code Quality](/fr/enterprise-cloud@latest/code-security/how-tos/maintain-quality-code/enable-code-quality) ».\n* Si vous avez activé Code Quality récemment, patientez quelques minutes pour que l’analyse initiale CodeQL de votre branche par défaut se termine.\n\nTout au long de ce tutoriel, nous allons utiliser un exemple en cours d’exécution : un référentiel dont le tableau de bord affiche actuellement des scores de « **Fiabilité : Médiocre** » et « **Maintenance : Juste** » pour la qualité du code.\n\n## Étape 1 : Évaluer votre score actuel\n\n1. Accédez à l’onglet ** Security and quality** de votre référentiel.\n2. Cliquez pour développer ** Qualité du code**, puis cliquez sur **Résultats standard**.\n\nIci, vous verrez des scores pour **la fiabilité** et **la facilité de maintenance**.\n\n\n\nCes scores sont calculés à partir des résultats de votre branche par défaut :\n\n| Metric | Definition | Exemples de résultats |\n| ------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- |\n| **Fiabilité** | Évaluez si le code effectue sa fonction prévue correctement, de manière prévisible et cohérente. Le code fiable est exempt de bogues, gère les erreurs en toute sécurité et fonctionne comme prévu dans des conditions normales et de cas de périphérie. | Problèmes liés aux performances, à la concurrence, à la gestion des erreurs, à la correction |\n| **Maintenabilité** | Évaluez la facilité de compréhension, de modification et d’extension du code au fil du temps. Le code gérable suit les meilleures pratiques, évite la complexité inutile et est organisé pour faciliter les modifications et la collaboration futures. | Code inutilisé ou mort, lisibilité, complexité, conventions de nommage incohérentes, mauvaise séparation des préoccupations |\n\nChaque score est déterminé par le niveau de gravité *le plus élevé* du constat encore présent pour cette métrique. Pour améliorer un score, vous devez résoudre chaque résultat du niveau de gravité le plus élevé actuel.\n\nDans notre exemple, **la fiabilité** est « Médiocre », car il existe toujours des résultats au niveau **de l’erreur** affectant la fiabilité. Les avertissements et les notes valent la peine d’être traités, mais jusqu’à ce que les erreurs soient effacées, elles ne peuvent pas déplacer le score.\n\n## Étape 2 : Lire la liste par règle et se concentrer sur les résultats les plus impactants\n\nDans la Résultats standard vue, les résultats sont regroupés par **règle**. Cela est utile pour comprendre, car une règle unique avec de nombreux résultats peut refléter une habitude de codage répétée. Une fois que vous avez compris une occurrence, il peut être plus facile de comprendre les corrections automatiques proposées pour l’ensemble des occurrences, ce qui rend la correction plus rapide et l’examen en bloc plus facile.\n\nEn outre, recherchez les règles qui compléteraient un niveau de gravité pour l’un de vos scores : si le fait de lever une règle supprime la dernière « Erreur » restante affectant la fiabilité, votre score augmente immédiatement.\n\nDans notre exemple, une règle — « Propriété remplacée » — représente 40 des 128 résultats, et les 40 sont de niveau Erreur. Le corriger supprimerait tous les problèmes de niveau Erreur affectant la fiabilité, ce qui ferait passer notre score à la tranche supérieure.\n\n## Étape 3 : Résoudre les résultats\n\nUne fois que vous avez choisi une règle, décidez comment gérer chaque recherche :\n\n| Assessment | Action recommandée | Notes |\n| ----------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| La conclusion est légitime. | Cliquez sur **Générer un correctif** et ouvrez une pull request | Cliquer sur **Générer le correctif** consomme AI credits. Vous pouvez ajouter plusieurs corrections automatiques à la même branche afin de regrouper le travail de remédiation dans une seule pull request. |\n| Le résultat ne s’applique pas. Par exemple, il se trouve dans du code hérité, un modèle intentionnel ou un faux positif | Cliquez sur **Ignorer**. | La recherche est considérée comme résolue et supprimée de la liste des résultats ouverts. |\n\nDans notre exemple, nous générons des corrections automatiques pour les 40 signalements « propriété écrasée » et ouvrons une pull request. Étant donné qu’ils partagent un modèle unique, les correctifs sont presque identiques. Nous fusionnons la pull request une fois que les vérifications CI ont réussi.\n\n## Étape 4 : Communiquer l’impact\n\nUne fois votre correctif fusionné, revenez à la vue « Résultats standard » et capturez :\n\n* **Score qui a changé.** Par exemple, *Fiabilité : Faible → Moyenne*.\n* **L’exigence qui l’a déverrouillée.** Par exemple, *tous les problèmes de niveau erreur affectant la fiabilité sont désormais résolus*.\n* **Réduction des résultats ouverts.** Par exemple, *de 128 ouvert à 88*.\n\nDans notre exemple, la suppression de la règle « Propriété écrasée » fait passer la fiabilité de **Médiocre** à **Passable** — la première amélioration de score que l’équipe peut mettre en avant.\n\n## Comment cela s’inscrit dans le reste de votre qualité de code\n\nChaque résultat que vous avez résolu aujourd’hui peut réapparaître demain si de nouvelles pull requests introduisent le même type de problème. Pour empêcher le backlog de se régénérer :\n\n* **Définissez un seuil de fusion sur votre branche par défaut** pour bloquer les pull requests qui introduisent de nouveaux problèmes de qualité du code. Consultez « [Définition des seuils de qualité du code pour les pull requests](/fr/enterprise-cloud@latest/code-security/how-tos/maintain-quality-code/set-pr-thresholds) ».\n* **Corrigez les problèmes dans la pull request dès qu’ils apparaissent**. Consultez « [Empêcher les problèmes de qualité du code d’atteindre votre branche par défaut](/fr/enterprise-cloud@latest/code-security/tutorials/improve-code-quality/catch-issues-before-merge) ».\n\n## Résolution des problèmes\n\n* **Les scores n’ont pas été déplacés après la fusion des correctifs.** Au moins une recherche au niveau de gravité le plus élevé actuel pour cette métrique est toujours ouverte.\n* **L’analyse n’a pas été réexécutée.**\n Code Quality les analyses s’exécutent automatiquement après chaque envoi (push) vers la branche par défaut. Attendez quelques minutes que le flux de travail se termine.\n\n## Conclusion\n\nDans ce tutoriel, vous avez évalué les scores de qualité de votre dépôt, priorisé les tâches du backlog selon leur gravité et la règle concernée, corrigé les problèmes détectés grâce aux corrections automatiques et présenté le résultat sous la forme d’une évolution du score.\n\n## Étapes suivantes\n\n* Réduisez davantage la dette technique en corrigeant les résultats dans les fichiers récemment modifiés. Consultez « [Correction des résultats de la qualité du code dans les fichiers récemment fusionnés](/fr/enterprise-cloud@latest/code-security/how-tos/maintain-quality-code/fix-findings-in-recent-merges) »."}