CLOC (Count Lines of Code) ist ein Befehlszeilentool, das die Dateien in einem Verzeichnis analysiert und die Anzahl der Codezeilen, Kommentare und Leerzeilen in einer Vielzahl von Programmiersprachen zählt. Es ist eine unschätzbare Ressource für Entwickler, die die Zusammensetzung ihrer Projekte verstehen, die Produktivität messen oder die Projektkomplexität abschätzen möchten.
CLOC (Count Lines of Code) ist ein leistungsstarkes Werkzeug, das Entwicklern hilft, ihre Codebasis zu analysieren, indem es die Anzahl der Codezeilen, Kommentare und Leerzeilen in mehreren Programmiersprachen zählt.
In diesem Schritt werden wir lernen, wie man CLOC mit seiner grundlegenden Syntax verwendet, um ein Projekt zu analysieren.
Die grundlegende Syntax für die Verwendung von CLOC lautet:
cloc [options] <file/directory>Lassen Sie uns CLOC verwenden, um das Flask-Projekt zu analysieren, das während der Einrichtung geklont wurde:
cd ~/project/flaskcloc .Der Punkt . steht für das aktuelle Verzeichnis. Dieser Befehl weist also CLOC an, alle Dateien im aktuellen Verzeichnis und seinen Unterverzeichnissen zu analysieren.
Nachdem der Befehl ausgeführt wurde, zeigt CLOC eine Tabelle mit folgenden Informationen an:
Die Ausgabe sollte in etwa so aussehen:
56 text files.
56 unique files.
16 files ignored.
github.com/AlDanial/cloc v 1.90 T=0.11 s (428.1 files/s, 72093.6 lines/s)
--------------------------------------------------------------------------------
Language files blank comment code
--------------------------------------------------------------------------------
Python 41 3061 2088 7012
Markdown 5 175 0 314
YAML 2 10 3 84
make 1 21 30 46
TOML 1 6 0 19
--------------------------------------------------------------------------------
SUM: 50 3273 2121 7475
--------------------------------------------------------------------------------Diese Ausgabe gibt Ihnen einen umfassenden Überblick über die Zusammensetzung der Codebasis des Flask-Projekts.
CLOC ermöglicht es Ihnen, bestimmte Dateitypen zu analysieren oder bestimmte Dateien von Ihrer Analyse auszuschließen. Dies ist besonders nützlich, wenn Sie an großen Projekten arbeiten, die mehrere Programmiersprachen enthalten.
Um nur Dateien mit bestimmten Erweiterungen zu analysieren, können Sie die Option --include-ext verwenden, gefolgt von einer durch Kommas getrennten Liste von Dateierweiterungen:
cd ~/project/flaskcloc --include-ext=py .Die Ausgabe zeigt nun nur Informationen zu Python-Dateien im Projekt:
41 text files.
41 unique files.
0 files ignored.
github.com/AlDanial/cloc v 1.90 T=0.05 s (886.0 files/s, 264066.7 lines/s)
-------------------------------------------------------------------------------
Language files blank comment code
-------------------------------------------------------------------------------
Python 41 3061 2088 7012
-------------------------------------------------------------------------------
SUM: 41 3061 2088 7012
-------------------------------------------------------------------------------Sie können auch bestimmte Verzeichnisse von Ihrer Analyse ausschließen, indem Sie die Option --exclude-dir verwenden:
cloc --exclude-dir=tests .Dieser Befehl analysiert das Flask-Projekt, schließt jedoch das Verzeichnis tests aus. Die Ausgabe zeigt Statistiken für alle Projekt-Dateien, außer denen im Verzeichnis tests:
34 text files.
34 unique files.
14 files ignored.
github.com/AlDanial/cloc v 1.90 T=0.07 s (372.3 files/s, 45941.8 lines/s)
--------------------------------------------------------------------------------
Language files blank comment code
--------------------------------------------------------------------------------
Python 25 1546 1103 3421
Markdown 5 175 0 314
YAML 2 10 3 84
make 1 21 30 46
TOML 1 6 0 19
--------------------------------------------------------------------------------
SUM: 34 1758 1136 3884
--------------------------------------------------------------------------------Durch die Verwendung dieser Filteroptionen können Sie Ihre Analyse auf bestimmte Teile der Codebasis konzentrieren, die für Ihre Bedürfnisse am relevantesten sind.
CLOC bietet Funktionen zum Vergleich verschiedener Projekte und zur Erstellung von Berichten in verschiedenen Formaten. Diese Möglichkeiten sind besonders nützlich, um Änderungen im Laufe der Zeit zu verfolgen oder verschiedene Codebasen zu vergleichen.
Erstellen wir ein einfaches Projekt, um es mit Flask zu vergleichen:
cd ~/projectmkdir sample_project
cd sample_projectecho 'def hello_world():
"""
A simple function that prints Hello World
"""
print("Hello, World!")
if __name__ == "__main__":
hello_world()' > main.pyecho 'class Calculator:
"""A simple calculator class"""
def add(self, a, b):
"""Add two numbers"""
return a + b
def subtract(self, a, b):
"""Subtract b from a"""
return a - b' > calculator.pycd ~/project
cloc --diff flask sample_projectDie Ausgabe zeigt die Unterschiede in den Code-Metriken zwischen den beiden Projekten:
2 text files.
2 unique files.
0 files ignored.
github.com/AlDanial/cloc v 1.90 T=0.01 s (195.2 files/s, 1756.8 lines/s)
-------------------------------------------------------------------------------
Language files blank comment code
-------------------------------------------------------------------------------
Python 2 3 4 11
-------------------------------------------------------------------------------
SUM: 2 3 4 11
-------------------------------------------------------------------------------
Diff by file type:
-------------------------------------------------------------------------------
Language files blank comment code
-------------------------------------------------------------------------------
Python 39 3058 2084 7001
Markdown 5 175 0 314
YAML 2 10 3 84
make 1 21 30 46
TOML 1 6 0 19
-------------------------------------------------------------------------------
SUM: 48 3270 2117 7464
-------------------------------------------------------------------------------CLOC kann Berichte in verschiedenen Formaten erstellen, darunter CSV und XML. Erstellen wir einen CSV-Bericht für das Flask-Projekt:
cd ~/project/flaskcloc --csv --out=flask_stats.csv .cat flask_stats.csvSie sollten die CLOC-Analyse in CSV-Format sehen:
files,language,blank,comment,code,"github.com/AlDanial/cloc v 1.90 T=0.09 s (571.3 files/s, 96263.8 lines/s)"
41,Python,3061,2088,7012
5,Markdown,175,0,314
2,YAML,10,3,84
1,make,21,30,46
1,TOML,6,0,19
50,SUM,3273,2121,7475Dieses CSV-Format ist besonders nützlich für den Import in Tabellenkalkulationen oder andere Datenanalyse-Tools.
Ebenso können Sie einen XML-Bericht erstellen:
cloc --xml --out=flask_stats.xml .Diese Berichterstellungsfunktionen machen CLOC zu einem vielseitigen Werkzeug für die Codeanalyse und Projektverwaltung.
CLOC bietet verschiedene erweiterte Optionen für detailliertere und angepasste Analysen. Diese Optionen ermöglichen es Ihnen, tiefere Einblicke in Ihre Codebasis zu gewinnen.
Bei der Analyse großer Projekte ist es hilfreich, den Fortschritt zu sehen. Verwenden Sie die Option --progress-rate, um Fortschrittsaktualisierungen anzuzeigen:
cd ~/project/flask
cloc --progress-rate=10 .Dieser Befehl zeigt nach der Verarbeitung von jeweils 10 Dateien eine Fortschrittsaktualisierung an.
Sie können Dateien analysieren, die einem bestimmten Muster entsprechen, indem Sie die Option --match-f verwenden:
cloc --match-f='test_.*\.py$' .Dieser Befehl zählt Codezeilen nur in Python-Dateien, die mit "test_" beginnen. Die Ausgabe zeigt Statistiken für Testdateien im Flask-Projekt:
15 text files.
15 unique files.
0 files ignored.
github.com/AlDanial/cloc v 1.90 T=0.03 s (541.8 files/s, 155547.1 lines/s)
-------------------------------------------------------------------------------
Language files blank comment code
-------------------------------------------------------------------------------
Python 15 1337 736 3193
-------------------------------------------------------------------------------
SUM: 15 1337 736 3193
-------------------------------------------------------------------------------Diese Funktion ist besonders nützlich, wenn Sie sich auf bestimmte Dateimuster innerhalb eines großen Projekts konzentrieren möchten.
Um eine Aufschlüsselung der Analyse nach einzelnen Dateien anstelle nur nach Sprache zu sehen, verwenden Sie die Option --by-file:
cloc --by-file --include-ext=py src/Dieser Befehl analysiert Python-Dateien im Verzeichnis src/ und zeigt Ergebnisse für jede Datei einzeln an:
7 text files.
7 unique files.
0 files ignored.
github.com/AlDanial/cloc v 1.90 T=0.01 s (648.3 files/s, 180431.1 lines/s)
-------------------------------------------------------------------------------
File blank comment code
-------------------------------------------------------------------------------
src/flask/ctx.py 123 193 539
src/flask/app.py 284 490 999
src/flask/blueprints.py 100 191 421
src/flask/cli.py 126 188 557
src/flask/helpers.py 136 227 538
src/flask/templating.py 28 60 123
src/flask/globals.py 22 63 74
-------------------------------------------------------------------------------
SUM: 819 1412 3251
-------------------------------------------------------------------------------Diese detaillierte Ansicht hilft Ihnen zu identifizieren, welche spezifischen Dateien am meisten zur Größe Ihrer Codebasis beitragen.
Diese erweiterten Optionen machen CLOC zu einem vielseitigen Werkzeug für umfassende Codeanalysen in verschiedenen Szenarien.
In diesem Lab haben Sie gelernt, wie Sie CLOC (Count Lines of Code) verwenden können, um Codebasen zu analysieren und wertvolle Einblicke in die Projektzusammensetzung zu gewinnen. Hier ist eine Zusammenfassung dessen, was Sie erreicht haben:
Grundlegende Nutzung: Sie haben gelernt, wie Sie den grundlegenden cloc-Befehl verwenden, um Verzeichnisse zu analysieren und die Anzahl der Codezeilen, Kommentare und Leerzeilen in verschiedenen Programmiersprachen zu zählen.
Filterung und Zielsetzung: Sie haben untersucht, wie Sie Ihre Analyse auf bestimmte Dateitypen beschränken können, indem Sie --include-ext verwenden, und wie Sie Verzeichnisse mit --exclude-dir ausschließen können.
Vergleich und Berichterstellung: Sie haben gelernt, wie Sie verschiedene Codebasen mithilfe der Option --diff vergleichen können und wie Sie Berichte in verschiedenen Formaten wie CSV und XML generieren können.
Erweiterte Analyse: Sie haben erweiterte Optionen entdeckt, die detailliertere Einblicke liefern, wie etwa die Fortschrittverfolgung, die Erkennung von doppelten Dateien, die Musterübereinstimmung und die Datei-für-Datei-Analyse.
CLOC ist ein leistungsstarkes Werkzeug für Entwickler, Projektmanager und Code-Auditoren, um die Größe und Komplexität von Codebasen zu quantifizieren. Indem Sie CLOC effektiv nutzen, können Sie:
Diese Funktionen machen CLOC zu einem unverzichtbaren Werkzeug in jedem Entwickler-Set für die Codeanalyse und Projektverwaltung.
