Complexité cyclomatique : guide du développeur

Les projets de développement logiciel modernes impliquent souvent des dizaines d'éléments mobiles assemblés de manière complexe par des programmeurs travaillant en équipes distribuées.

Lorsque le code sous-jacent, dans son architecture et sa mise en œuvre, est moins complexe, il est plus facile à comprendre.

Et lorsque vous comprenez votre base de code, cela contribue grandement à améliorer sa qualité et sa maintenabilité.

La complexité cyclomatique est une mesure quantitative de la complexité d'un programme informatique utilisée en informatique.

En substance, elle reflète le nombre de chemins linéairement indépendants à travers le code source d'un programme.

En surveillant cette métrique, vous pouvez identifier les zones de code potentiellement problématiques ou trop complexes, ce qui les rend plus difficiles à maintenir et plus susceptibles d'erreurs.

Comprendre la complexité cyclomatique vous aidera à écrire un code meilleur et plus propre.

Dans cet article, nous allons explorer ce qu'est la complexité cyclomatique, comment elle est calculée et pourquoi elle est importante. Nous discuterons également de la manière de tester et d'analyser cette complexité, ainsi que des outils disponibles pour vous aider à la gérer efficacement.

Qu'est-ce que la complexité cyclomatique ?

La complexité cyclomatique est une métrique d'ingénierie logicielle introduite par Thomas J. McCabe en 1976. Cette métrique est un score numérique qui représente le nombre de chemins différents qu'un programme peut emprunter pendant son exécution.

Un score élevé signifie plus de chemins d'exécution (complexité plus élevée), tandis qu'un score faible signifie moins de chemins (complexité plus faible).

Les programmes présentant une complexité cyclomatique élevée ont tendance à être plus sujets aux erreurs et plus difficiles à tester et à maintenir. En revanche, une valeur de complexité cyclomatique plus faible suggère que le programme est très lisible et plus facile à comprendre, à tester et à modifier.

En quantifiant la complexité d'un programme, les développeurs sont mieux préparés à aborder et à hiérarchiser les modifications du code, la refactorisation et les tests. Lorsqu'il s'agit de gérer des bases de code plus importantes, où le risque de bogues augmente avec la complexité, la mesure de la complexité cyclomatique devient particulièrement utile.

Quelle est la formule pour calculer la complexité cyclomatique ?

La formule pour calculer la complexité cyclomatique est relativement simple. Commencez par observer le graphe de flux de contrôle du programme, une représentation graphique de tous les chemins qui peuvent être parcourus par un programme pendant son exécution.

1. Exemples de graphiques de flux de contrôle pour des scénarios de programmation simples
   (a) instruction if-then-else
   (b) boucle while
   (c) boucle naturelle avec une instruction if break au milieu
   (d) boucle avec deux points d'entrée

Source

En examinant un graphique de flux de contrôle, nous représenterions le nombre d'arêtes dans le graphique par E, tandis que N représente le nombre de nœuds dans le graphique.

La formule pour calculer la complexité cyclomatique C est la suivante:

C = E - N + 2P

où P représente le nombre de composants connectés. Pour un programme unique, P = 1.

Ce calcul nous donne le nombre de chemins linéairement indépendants dans le code. Il indique le nombre minimum de chemins que vous devez tester pour vous assurer que chaque point de décision est exécuté au moins une fois. Lorsque C est élevé, votre code est plus complexe et comporte davantage de chemins, ce qui signifie que la maintenance et les tests peuvent nécessiter davantage d'efforts.

Une conclusion simple que nous pouvons tirer de l'examen de la complexité cyclomatique est la suivante : les instructions if, while, for ou switch ajoutent de la complexité, car chaque condition introduit un nouveau chemin dans le flux du programme. En tant que développeur, vous pouvez examiner cette formule et évaluer rapidement la complexité de n'importe quelle partie de votre programme.

Comprendre et appliquer cette formule vous aidera à garder votre code propre, efficace et facile à maintenir.

Quel est un exemple de complexité cyclomatique ?

Pour illustrer la complexité cyclomatique à l'aide d'un exemple pratique, examinons un morceau de code de base écrit en JavaScript. Cet exemple nous aidera à comprendre comment la complexité cyclomatique est calculée et pourquoi elle est importante.

Cette fonction JavaScript simple vérifie si un utilisateur a droit à une réduction en fonction de diverses conditions:

function checkDiscount(age, membershipDuration) {
  let discount;
  if (age > 60) {
    discount = 25; // Senior discount
  } else if (membershipDuration > 5) {
    discount = 15; // Loyalty discount
  } else {
    discount  0; // No discount
  }
  return discount;
}

Nous pouvons représenter ces lignes de code à l'aide du graphique de flux de contrôle suivant:

Voyons comment calculer la complexité cyclomatique.

Tout d'abord, recherchons les points de décision dans la fonction. Dans notre exemple, il y a deux conditions :

• if (âge > 60)
• else if (durée d'adhésion > 5).

Chaque point de décision peut mener à des résultats différents :

• La condition âge > 60 est vraie
• La première condition est fausse, mais durée d'adhésion > 5 est vraie.
• Les deux conditions sont fausses.

Si l'on examine le graphe de flux de contrôle, le nombre total d'arêtes est de 8. Le nombre total de nœuds est de 7. Et comme la fonction entière est un composant connecté unique, P = 1. Lorsque l'on applique la formule, on obtient :

C = E - N + 2P

= 8 - 7 + 2(1)

= 3

Ce score de complexité cyclomatique de 3 indique qu'il existe trois chemins distincts dans le code. Chacun de ces chemins doit être testé pour s'assurer que tous les scénarios sont couverts. En décomposant méthodiquement notre code de cette manière, nous clarifions ce qui est nécessaire pour les tests logiciels et mettons en évidence la complexité de notre code, une complexité qui pourrait potentiellement être simplifiée.

Comment tester la complexité cyclomatique

Tester la complexité cyclomatique signifie simplement s'assurer que vous avez correctement testé tous les chemins possibles dans votre programme. Une couverture adéquate du code de test est importante si vous souhaitez maintenir la qualité et la fiabilité de votre code à un niveau élevé.

Après avoir calculé la complexité cyclomatique de votre code, décomposez-le pour identifier ces chemins. Voici une astuce : chaque point de décision dans votre code (tel que les instructions conditionnelles ou les boucles) contribue généralement à un nouveau chemin.

Une fois que vous avez identifié vos chemins, créez des cas de test pour chacun d'entre eux. L'objectif est d'exécuter chaque chemin au moins une fois. Cela garantit que tous les aspects fonctionnels du code sont testés et vous aidera à détecter les erreurs potentielles dans la logique du code.

Utilisez des outils de test automatisés pour exécuter vos cas de test. Après avoir analysé les résultats des tests, vérifiez s'il y a des échecs ou des comportements inattendus. Chaque cas de test échoué peut indiquer un bug ou une faille dans ce chemin de votre code source.

Si tous vos tests sont réussis mais que vous estimez que la complexité cyclomatique est trop élevée, vous pouvez envisager de refactoriser le code afin de le simplifier. Cela peut impliquer de décomposer des fonctions complexes en fonctions plus simples ou de réduire le nombre de points de décision. Après la refactorisation, répétez le processus de test afin de vous assurer que le nouveau code maintient ou améliore la qualité.

En déterminant régulièrement la complexité cyclomatique, puis en testant votre code en conséquence, vous pouvez maintenir un niveau de complexité gérable. Cela simplifie le processus de test et votre base de code, ce qui permet d'obtenir un logiciel plus fiable et plus facile à maintenir.

Comment effectuer une analyse de la complexité cyclomatique

L'analyse de la complexité cyclomatique du code consiste à examiner le code source de votre programme afin de comprendre sa structure et d'identifier les domaines dans lesquels la complexité peut être réduite.

Pour ce faire, vous devez commencer par rassembler tout le code source qui doit être analysé. Il peut s'agir d'un module spécifique, d'un ensemble de fonctions, voire d'une application entière, selon votre objectif.

Vous pouvez utiliser des outils tels que des analyseurs de code statiques pour automatiser le processus de calcul de la complexité cyclomatique de chaque fonction ou module. Ces outils vous aideront à obtenir un aperçu rapide de la complexité de votre code.

À partir de là, identifiez les parties du code présentant des scores de complexité élevés. Ce sont les zones qui peuvent être potentiellement difficiles à comprendre, à tester et à maintenir. Donnez la priorité aux zones qui doivent être refactorisées. La détermination de ces zones dépendra de leur complexité et de l'importance de leur fonctionnalité au sein de l'application. Concentrez-vous sur les zones où la réduction de la complexité apportera des avantages significatifs en termes de maintenabilité et de fiabilité.

Au fur et à mesure que vous refactorisez et que la complexité cyclomatique diminue, vous constaterez peut-être que le nombre de cas de test diminue également. Après la refactorisation, relancez vos tests (qui ont également été réécrits) pour vous assurer que vous n'avez rien endommagé. Ensuite, recalculez la complexité cyclomatique pour vous assurer que vos modifications ont effectivement réduit la complexité.

En effectuant régulièrement des analyses de complexité cyclomatique, les équipes de développement peuvent gérer de manière proactive leur base de code, en s'assurant qu'elle reste propre, testable et maintenable. Cette pratique vous aidera à améliorer la qualité du code et, au final, rendra vos processus de développement plus efficaces.

Quels sont les outils et logiciels permettant d'analyser la complexité cyclomatique ?

Il est essentiel d'identifier et de traiter les zones de code présentant une complexité cyclomatique élevée afin de maintenir un logiciel de haute qualité et maintenable. De nombreux outils et solutions logicielles sont disponibles pour aider les développeurs à évaluer et à surveiller cette complexité.

• SonarQube Server est un outil complet de qualité du code qui s'intègre directement dans votre flux de travail de développement. Il fournit des rapports détaillés sur la complexité cyclomatique, entre autres métriques logicielles. SonarQube Server aide à identifier le code complexe qui pourrait nécessiter une refactorisation et prend en charge plus de 30 langages de programmation (dont Java, Python, Go) et frameworks.
• SonarQube Cloud est un service basé sur le cloud qui fournit une revue de code automatisée pour l'analyse de la complexité. Il est particulièrement utile pour l'intégration continue/le déploiement continu (CI/CD) et l'environnement de plateforme DevOps, offrant un retour d'information en temps réel sur les modifications du code et leur impact sur la complexité.
• SonarQube for IDE est un plugin IDE qui fournit des commentaires en temps réel aux développeurs pendant qu'ils écrivent du code, les aidant ainsi à maintenir une faible complexité dès le début. Il peut être utilisé dans des IDE populaires tels que Visual Studio, Eclipse et IntelliJ IDEA.

Ces outils fournissent des informations précieuses sur la complexité du code, aidant les équipes à prendre des décisions éclairées sur les domaines dans lesquels concentrer leurs efforts de refactorisation afin d'améliorer la maintenabilité et de simplifier le débogage.

Conclusion

Il est important de comprendre et de gérer la complexité cyclomatique si vous souhaitez développer des logiciels propres et de haute qualité. Cette métrique sert de guide aux développeurs pour identifier les zones susceptibles d'être sujettes à des erreurs ou difficiles à maintenir. En mesurant et en analysant régulièrement la complexité cyclomatique, vous pouvez vous assurer que votre code est à la fois efficace et maintenable.

Pour commencer à utiliser des outils qui vous aideront à maintenir une faible complexité cyclomatique et une qualité logicielle élevée, utilisez gratuitement les outils SonarSource dès aujourd'hui.