Moderne Softwareentwicklungsprojekte umfassen oft Dutzende von beweglichen Teilen, die von Programmierern in verteilten Teams aufwendig zusammengesetzt werden.
Wenn der zugrunde liegende Code – in seiner Architektur und Implementierung – weniger komplex ist, ist er leichter zu verstehen.
Und wenn Sie Ihre Codebasis verstehen, trägt dies wesentlich zur Verbesserung ihrer Qualität und Wartbarkeit bei.
Die zyklomatische Komplexität ist ein quantitatives Maß für die Komplexität eines Computerprogramms, das in der Informatik verwendet wird.
Im Wesentlichen spiegelt sie die Anzahl der linear unabhängigen Pfade durch den Quellcode eines Programms wider.
Durch die Überwachung dieser Metrik können Sie Code-Bereiche identifizieren, die potenziell problematisch oder übermäßig komplex sind, wodurch sie schwieriger zu warten und anfälliger für Fehler sind.
Das Verständnis der zyklomatischen Komplexität hilft Ihnen, besseren und saubereren Code zu schreiben.
In diesem Beitrag werden wir untersuchen, was zyklomatische Komplexität ist, wie sie berechnet wird und warum sie wichtig ist. Wir werden auch diskutieren, wie diese Komplexität getestet und analysiert werden kann, und welche Tools Ihnen dabei helfen, sie effektiv zu verwalten.
Was ist zyklomatische Komplexität?
Zyklomatische Komplexität ist eine Metrik aus dem Bereich der Softwareentwicklung, die 1976 von Thomas J. McCabe eingeführt wurde. Diese Metrik ist ein numerischer Wert, der die Anzahl der verschiedenen Pfade angibt, die ein Programm während seiner Ausführung nehmen kann.
Ein höherer Wert bedeutet mehr Ausführungspfade (höhere Komplexität), während ein niedrigerer Wert weniger Pfade (geringere Komplexität) bedeutet.
Programme mit hoher zyklomatischer Komplexität sind in der Regel fehleranfälliger und schwieriger zu testen und zu warten. Ein niedrigerer Wert für die zyklomatische Komplexität deutet hingegen darauf hin, dass das Programm gut lesbar und leichter zu verstehen, zu testen und zu modifizieren ist.
Durch die Quantifizierung der Komplexität eines Programms sind Entwickler besser darauf vorbereitet, Codeänderungen, Refactorings und Tests anzugehen und zu priorisieren. Bei der Verwaltung größerer Codebasen, bei denen das Risiko von Fehlern mit der Komplexität zunimmt, ist die Metrik der zyklomatischen Komplexität besonders nützlich.
Wie lautet die Formel für die zyklomatische Komplexität?
Die Formel zur Berechnung der zyklomatischen Komplexität ist relativ einfach. Beginnen Sie mit der Betrachtung des Kontrollflussdiagramms des Programms – einer grafischen Darstellung aller Pfade, die während der Ausführung eines Programms durchlaufen werden können.
- Beispiele für Kontrollflussgraphen einfacher Programmierszenarien
(a) if-then-else-Anweisung
(b) while-Schleife
(c) eine natürliche Schleife mit einer if-Anweisung break in der Mitte
(d) eine Schleife mit zwei Einstiegspunkten
Betrachtet man einen Kontrollflussgraphen, würde man die Anzahl der Kanten im Graphen als E darstellen, während N die Anzahl der Knoten im Graphen darstellt.
Die Formel für die zyklomatische Komplexität C lautet:
C = E - N + 2P
wobei P die Anzahl der verbundenen Komponenten darstellt. Für ein einzelnes Programm ist P = 1.
Diese Berechnung ergibt die Anzahl der linear unabhängigen Pfade durch den Code. Sie gibt die Mindestanzahl an Pfaden an, die Sie testen müssen, um sicherzustellen, dass jeder Entscheidungspunkt mindestens einmal ausgeführt wird. Wenn C hoch ist, haben Sie einen komplexeren Code mit mehr Pfaden – was potenziell einen höheren Wartungs- und Testaufwand bedeutet.
Eine einfache Schlussfolgerung, die wir aus der Betrachtung der zyklomatischen Komplexität ziehen können, lautet: if-, while-, for- oder switch-Anweisungen erhöhen die Komplexität, da jede Bedingung einen neuen Pfad im Programmablauf einführt. Als Entwickler können Sie anhand dieser Formel schnell die Komplexität eines beliebigen Teils Ihres Programms einschätzen.
Das Verständnis und die Anwendung dieser Formel helfen Ihnen, Ihren Code sauber, effizient und wartbar zu halten.
Was ist ein Beispiel für zyklomatische Komplexität?
Um die zyklomatische Komplexität anhand eines praktischen Beispiels zu veranschaulichen, betrachten wir einen einfachen Code, der in JavaScript geschrieben ist. Dieses Beispiel hilft uns zu verstehen, wie die zyklomatische Komplexität berechnet wird und warum sie wichtig ist.
Diese einfache JavaScript-Funktion prüft anhand verschiedener Bedingungen, ob ein Benutzer Anspruch auf einen Rabatt hat:
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;
}Wir können diese Codezeilen mit dem folgenden Kontrollflussdiagramm darstellen:
Sehen wir uns einmal an, wie wir die zyklomatische Komplexität berechnen würden.
Zunächst suchen wir nach Entscheidungspunkten in der Funktion. In unserem Beispiel gibt es zwei Bedingungen:
- if (age > 60)
- else if (membershipDuration > 5).
Jeder Entscheidungspunkt kann zu unterschiedlichen Ergebnissen führen:
- Die Bedingung age > 60 ist wahr
- Die erste Bedingung ist falsch, aber membershipDuration > 5 ist wahr.
- Beide Bedingungen sind falsch.
Wenn wir uns den Kontrollflussgraphen ansehen, beträgt die Gesamtzahl der Kanten 8. Die Gesamtzahl der Knoten beträgt 7. Und da die gesamte Funktion eine einzige verbundene Komponente ist, ist P = 1. Wenn wir die Formel anwenden, erhalten wir Folgendes:
C = E - N + 2P
= 8 - 7 + 2(1)
= 3
Dieser zyklomatische Komplexitätswert von 3 zeigt an, dass es drei verschiedene Pfade durch den Code gibt. Jeder dieser Pfade muss getestet werden, um sicherzustellen, dass alle Szenarien abgedeckt sind. Indem wir unseren Code methodisch aufschlüsseln, klären wir, was für das Testen von Software erforderlich ist, und heben die Komplexität in unserem Code hervor – eine Komplexität, die möglicherweise vereinfacht werden könnte.
So testen Sie die zyklomatische Komplexität
Das Testen der zyklomatischen Komplexität bedeutet, einfach ausgedrückt, dass Sie sicherstellen, dass Sie alle möglichen Pfade in Ihrem Programm ausreichend getestet haben. Eine ausreichende Testcodeabdeckung ist wichtig, wenn Sie die Qualität und Zuverlässigkeit Ihres Codes hoch halten möchten.
Nachdem Sie die zyklomatische Komplexität Ihres Codes berechnet haben, zerlegen Sie Ihren Code, um diese Pfade zu identifizieren. Hier ein Tipp: Jeder Entscheidungspunkt in Ihrem Code (z. B. bedingte Anweisungen oder Schleifen) trägt in der Regel zu einem neuen Pfad bei.
Sobald Sie Ihre Pfade identifiziert haben, erstellen Sie für jeden einzelnen Testfälle. Das Ziel ist es, jeden Pfad mindestens einmal auszuführen. Dadurch wird sichergestellt, dass alle funktionalen Aspekte des Codes getestet werden, und es hilft Ihnen, potenzielle Fehler in der Codelogik zu finden.
Verwenden Sie automatisierte Testtools, um Ihre Testfälle auszuführen. Überprüfen Sie nach der Analyse der Testergebnisse, ob Fehler oder unerwartete Verhaltensweisen aufgetreten sind. Jeder fehlgeschlagene Testfall kann auf einen Fehler oder eine Schwachstelle in diesem Pfad Ihres Quellcodes hinweisen.
Wenn alle Ihre Tests erfolgreich sind, Sie aber der Meinung sind, dass die zyklomatische Komplexität zu hoch ist, können Sie eine Umgestaltung des Codes in Betracht ziehen, um ihn zu vereinfachen. Dies kann die Aufteilung komplexer Funktionen in einfachere Funktionen oder die Reduzierung der Anzahl der Entscheidungspunkte beinhalten. Wiederholen Sie nach der Umgestaltung den Testprozess, um sicherzustellen, dass der neue Code die Qualität beibehält oder verbessert.
Indem Sie regelmäßig die zyklomatische Komplexität bestimmen und Ihren Code entsprechend testen, können Sie ein überschaubares Maß an Komplexität aufrechterhalten. Dies vereinfacht den Testprozess und Ihre Codebasis und führt zu einer zuverlässigeren und wartungsfreundlicheren Software.
So führen Sie eine zyklomatische Komplexitätsanalyse durch
Bei der zyklomatischen Komplexitätsanalyse wird der Quellcode Ihres Programms überprüft, um dessen Struktur zu verstehen und Bereiche zu identifizieren, in denen die Komplexität reduziert werden kann.
Dazu sammeln Sie zunächst den gesamten zu analysierenden Quellcode. Dies kann ein bestimmtes Modul oder eine Reihe von Funktionen sein – oder sogar eine gesamte Anwendung –, je nachdem, worauf Sie sich konzentrieren.
Sie können Tools wie statische Code-Analysatoren verwenden, um die Berechnung der zyklomatischen Komplexität für jede Funktion oder jedes Modul zu automatisieren. Diese Tools helfen Ihnen dabei, sich einen schnellen Überblick über die Komplexität Ihres Codes zu verschaffen.
Identifizieren Sie anschließend alle Teile des Codes mit hohen Komplexitätswerten. Dies sind die Bereiche, die möglicherweise schwer zu verstehen, zu testen und zu warten sind. Priorisieren Sie die Bereiche, die refaktoriert werden sollten. Welche Bereiche dies sind, hängt von ihrer Komplexität und der Kritikalität ihrer Funktionalität innerhalb der Anwendung ab. Konzentrieren Sie sich auf Bereiche, in denen eine Verringerung der Komplexität erhebliche Vorteile für die Wartbarkeit und Zuverlässigkeit mit sich bringt.
Wenn Sie die Refaktorisierung durchführen und die zyklomatische Komplexität abnimmt, werden Sie möglicherweise feststellen, dass auch die Anzahl Ihrer Testfälle abnimmt. Führen Sie nach der Refaktorisierung Ihre Tests (die ebenfalls neu geschrieben wurden) erneut durch, um sicherzustellen, dass Sie nichts beschädigt haben. Berechnen Sie dann die zyklomatische Komplexität neu, um sicherzustellen, dass Ihre Änderungen die Komplexität effektiv reduziert haben.
Durch die regelmäßige Durchführung von zyklomatischen Komplexitätsanalysen können Entwicklungsteams ihre Codebasis proaktiv verwalten und sicherstellen, dass sie sauber, testbar und wartbar bleibt. Diese Vorgehensweise hilft Ihnen, die Codequalität zu verbessern, und macht Ihre Entwicklungsprozesse letztendlich effizienter.
Welche Tools und Software gibt es für zyklomatische Komplexität?
Die Identifizierung und Bearbeitung von Code-Bereichen mit hoher zyklomatischer Komplexität ist entscheidend für die Aufrechterhaltung einer hochwertigen, wartbaren Software. Es gibt viele Tools und Softwarelösungen, die Entwicklern bei der Bewertung und Überwachung dieser Komplexität helfen.
- SonarQube Server ist ein umfassendes Tool zur Codequalität, das sich direkt in Ihren Entwicklungsworkflow integrieren lässt. Es liefert detaillierte Berichte zur zyklomatischen Komplexität sowie zu anderen Softwaremetriken. SonarQube Server hilft bei der Identifizierung komplexer Codes, die möglicherweise refaktoriert werden müssen, und unterstützt mehr als 30 Programmiersprachen (einschließlich Java, Python, Go) und Frameworks.
- SonarQube Cloud ist ein cloudbasierter Dienst, der eine automatisierte Codeüberprüfung für die Komplexitätsanalyse bietet. Dies ist besonders nützlich für Continuous Integration/Continuous Deployment (CI/CD) und DevOps-Plattformumgebungen, da es Echtzeit-Feedback zu Codeänderungen und deren Auswirkungen auf die Komplexität bietet.
- SonarQube for IDE ist ein IDE-Plugin, das Entwicklern während des Schreibens von Code sofortiges Feedback gibt und ihnen hilft, von Anfang an eine geringe Komplexität aufrechtzuerhalten. Es kann in gängigen IDEs wie Visual Studio, Eclipse und IntelliJ IDEA verwendet werden.
Diese Tools liefern wertvolle Einblicke in die Komplexität von Code und helfen Teams, fundierte Entscheidungen darüber zu treffen, wo sie ihre Refactoring-Bemühungen konzentrieren sollten, um die Wartbarkeit zu verbessern und die Fehlersuche zu vereinfachen.
Fazit
Das Verständnis und Management der zyklomatischen Komplexität ist wichtig, wenn Sie saubere und hochwertige Software entwickeln möchten. Diese Metrik dient Entwicklern als Leitfaden, um Bereiche zu identifizieren, die fehleranfällig oder schwer zu warten sind. Durch regelmäßige Messung und Analyse der zyklomatischen Komplexität können Sie sicherstellen, dass Ihr Code sowohl effizient als auch wartbar ist.
Um mit Tools zu beginnen, die Ihnen helfen, Ihre zyklomatische Komplexität niedrig und Ihre Softwarequalität hoch zu halten, nutzen Sie SonarSource-Tools noch heute kostenlos.