Quelle est la complexité cyclomatique?
Un terme que je vois de temps en temps est une "complexité cyclomatique". Ici sur SO j'ai vu des questions sur "Comment calculer le CC de la langue x" ou "Comment puis-je faire y avec la quantité minimale de CC", mais je ne suis pas sûr de bien comprendre ce qu'il est.
Sur le Site Web Ndepend , j'ai vu une explication qui dit essentiellement "le nombre de décisions dans une méthode. Chacun si, pour, && etc. ajoute +1 au" score "cc). Est-ce vraiment C'est si oui, pourquoi est-ce mauvais? Je peux voir que l'on pourrait vouloir garder le nombre de déclarations si assez bas pour que le code soit facile à comprendre, mais est-ce vraiment tout?
Ou y a-t-il un concept plus profond?
Je ne suis pas au courant d'un concept plus profond. Je crois que cela est généralement pris en compte dans le contexte d'un indice de maintenabilité. Plus il y a de branches dans une méthode particulière, plus il est difficile de maintenir un modèle mental de l'opération de cette méthode (en général).
Les méthodes présentant une complexité cyclomatique plus élevée sont également plus difficiles à obtenir une couverture de code complète sur des tests unitaires. (Merci Mark W !)
Cela amène tous les autres aspects de la maintenabilité dans, bien sûr. Probabilité d'erreurs/régressions/ainsi de suite. Le concept de base est cependant assez simple.
La complexité cyclomatique mesure le nombre de fois que vous devez exécuter un bloc de code avec des paramètres variables afin d'exécuter chaque chemin à travers ce bloc. Un nombre plus élevé est mauvais car il augmente les chances d'erreurs logiques qui échappent à votre stratégie de test.
Cyclocmatic complexity = Number of decision points + 1
Les points de décision peuvent être vos déclarations conditionnelles telles que si, si ... d'autre, commutateur, pour boucle, tandis que la boucle, etc.
Le graphique suivant décrit le type de l'application.
La complexité cyclomatique est de 1 à 10 être considérée comme une applicatinon normale
La complexité cyclomatique se trouve 11 - 20 Application modérée
La complexité cyclomatique se trouve 21 - 50 Application risquée
La complexité cyclomatique réside plus de 50 une application instable
Wikipedia peut être votre ami sur celui-ci: Définition de la complexité cyclomatique
Fondamentalement, vous devez imaginer votre programme en tant que graphique de contrôle de contrôle puis
La complexité est (...) définie comme suit:
M = E − N + 2Poù
- M = complexité cyclomatique,
- E = le nombre de bords du graphique
- N = le nombre de nœuds du graphique
- P = le nombre de composants connectés
CC est un concept qui tente de capturer la complexité de votre programme et de la difficulté de la tester dans un seul nombre entier.
Un autre point intéressant que j'ai entendu:
Les endroits de votre code avec les plus gros endosses devraient avoir le cc le plus élevé. Ce sont généralement les domaines les plus importants pour assurer la couverture des tests, car elle devrait être plus difficile à lire/à entretenir. Comme d'autres réponses note, celles-ci constituent également les régions les plus difficiles du code pour assurer la couverture.
La complexité cyclomatique n'est vraiment qu'un mot à la mode effrayant. En fait, il s'agit d'une mesure de la complexité du code utilisé dans le développement de logiciels pour signaler plus de parties complexes du code (plus susceptibles d'être buggy, et doit donc être testé très soigneusement et minutieusement). Vous pouvez le calculer à l'aide de la formule E-N + 2P, mais je vous suggère que vous avez ceci calculé automatiquement par un plugin. J'ai entendu parler d'une règle de base que vous devriez vous efforcer de garder le CC ci-dessous 5 pour maintenir une bonne lisibilité et la maintenabilité de votre code.
Je viens de récemment expérimenté le plugin métrique Eclipse sur mon Java projets, et il dispose d'un fichier d'aide vraiment agréable et concis qui va bien sûr intégrer à votre éclipse régulière Aide et vous pouvez lire des définitions supplémentaires de différentes mesures de complexité et astuces sur l'amélioration de votre code.
C'est tout, l'idée est qu'une méthode qui a un faible cc a moins de fourchettes, de bouclage, etc. qui font tous une méthode plus complexe. Imaginez passer en revue 500 000 lignes de code, avec un analyseur et voir quelques méthodes qui ont une ampleur de magnitude supérieure à CC. Cela vous permet ensuite de me concentrer sur la refactorise ces méthodes pour une meilleure compréhension (il est également courant qu'un taux de bogue élevé a un taux de bogue élevé)
Chaque point de décision dans une routine (boucle, commutateur, si, etc ...) résume essentiellement à une instruction si équivalente. Pour chaque if, vous avez 2 codépaths pouvant être pris. Donc, avec la 1ère branche, il y a 2 chemins de code, avec le second, il y a 4 chemins possibles, avec le 3ème il y en a 8, etc. Il y a au moins 2 ** n chemins de code où n est le nombre de branches.
Cela rend difficile la compréhension du comportement du code et de le tester lorsque N augmente au-delà d'un petit nombre.
La complexité cyclomatique est calculée à l'aide du graphe de contrôle. Le nombre de mesures quantitatives de chemins indépendants linéairement par le biais du code source d'un programme est appelé complexité cyclomatique (si/si sinon/pour/alors)
Les réponses fournies jusqu'à présent ne mentionnent pas la corrélation de la qualité logicielle à la complexité cyclomatique. Des recherches ont montré qu'une métrique de complexité cyclomatique inférieure devrait aider à développer des logiciels de meilleure qualité. Il peut vous aider avec les attributs de qualité logicielle de la lisibilité, de la maintenabilité et de la portabilité. En général, il faut tenter d'obtenir une métrique de complexité cyclomatique comprise entre 5 et 10.
L'une des raisons d'utiliser des métriques telles que la complexité cyclomatique est que, en général, un être humain ne peut garder une trace d'environ 7 (plus ou moins 2) des informations simultanément dans votre cerveau. Par conséquent, si votre logiciel est trop complexe avec plusieurs chemins de décision, il est peu probable que vous puissiez visualiser comment votre logiciel se comportera (c'est-à-dire une métrique de complexité cyclomatique élevée). Cela conduirait probablement à développer des logiciels erronés ou bugs. Plus d'informations à ce sujet peuvent être trouvées ICI et aussi sur Wikipedia .
Considérons le Graphique de contrôle de contrôle de votre fonction, avec un bord supplémentaire en cours d'exécution de la sortie à l'entrée. La complexité cyclomatique est le nombre maximal de coupes que nous pouvons faire sans séparer le graphique en deux morceaux.
Par exemple:
function F:
if condition1:
...
else:
...
if condition2:
...
else:
...
Graphique de contrôle de contrôle
Vous pouvez probablement voir de manière intuitive pourquoi le graphique lié a une complexité cyclomatique de 3.
La complexité cyclomacatrique est essentiellement une métrique pour déterminer les zones de code qui nécessitent plus d'une fréquentation pour la maintenabilité. Ce serait fondamentalement une contribution au refactoring. Il donne définitivement une indication de la zone d'amélioration du code en termes d'éviter une boucle imbriquée profonde, etc.
C'est une sorte de ça. Cependant, chaque branche d'une "affaire" ou "commutateur" a tendance à compter comme 1. En effet, cela signifie que cc déteste comptes de cas, et tout code qui les oblige à les obliger (les processeurs de commande, les machines d'état, etc).
La complexité cyclomacatrique est une mesure de la complexité d'une unité de logiciels.Le mesure le nombre de chemins différents un programme pourrait suivre avec des constructions logiques conditionnelles (si, pendant, des commutateurs et des cas, etc.). Si vous souhaitez en savoir plus sur le calculer ici est une merveilleuse vidéo YouTube, vous pouvez regarder https://www.youtube.com/watch?v=plcgomvu-nm
Il est important de concevoir des cas de test car il révèle les différents chemins ou scénarios qu'un programme peut prendre. "Pour avoir une bonne vérification et une bonne maintenabilité, McCabe recommande qu'aucun module de programme ne dépasse une complexité cyclomatique de 10" (Marsic, 2012, p. 232).
Référence: Marsic., I. (2012, septembre). Génie logiciel . Université Rutgers. Récupéré de www.ece.rutgers.edu/~marsic/books/se/book-se_marsic.pdf