Wie werden alle Codezeilen in einem Verzeichnis rekursiv gezählt?

Wir haben eine PHP-Anwendung und möchten alle Codezeilen unter einem bestimmten Verzeichnis und seinen Unterverzeichnissen zählen. Wir müssen Kommentare nicht ignorieren, da wir nur versuchen, eine grobe Vorstellung zu bekommen.

wc -l *.php 

Dieser Befehl funktioniert in einem bestimmten Verzeichnis hervorragend, ignoriert jedoch Unterverzeichnisse. Ich dachte, das könnte funktionieren, aber es gibt 74 zurück, was definitiv nicht der Fall ist ...

find . -name '*.php' | wc -l

Was ist die richtige Syntax, um alle Dateien einzugeben?

Versuchen:

find . -name '*.php' | xargs wc -l

Das SLOCCount-Tool kann ebenfalls hilfreich sein.

Es gibt eine genaue Anzahl der Quellcodezeilen für jede Hierarchie, auf die Sie zeigen, sowie einige zusätzliche Statistiken.

Sortierte Ausgabe:

find . -name '*.php' | xargs wc -l | sort -nr

Für einen anderen Einzeiler:

( find ./ -name '*.php' -print0 | xargs -0 cat ) | wc -l

arbeitet mit Namen mit Leerzeichen, gibt nur eine Zahl aus.

Wenn Sie eine anständige aktuelle Version von Bash (oder ZSH) verwenden, ist dies viel einfacher:

wc -l **/*.php

In der Bash-Shell muss hierfür die globstarOption festgelegt werden, andernfalls ist der **Glob-Operator nicht rekursiv. Problem, um diese Einstellung zu aktivieren

shopt -s globstar

Um dies dauerhaft zu machen, fügen Sie es zu einem der Initialisierung Dateien ( ~/.bashrc, ~/.bash_profileetc.).

Sie können das clocDienstprogramm verwenden, das genau für diesen Zweck erstellt wurde. Es gibt jeweils die Anzahl der Zeilen in jeder Sprache sowie die Anzahl der Kommentare usw. an. CLOC ist unter Linux, Mac und Windows verfügbar.

Verwendungs- und Ausgabebeispiel:

$ cloc --exclude-lang=DTD,Lua,make,Python .
    2570 text files.
    2200 unique files.                                          
    8654 files ignored.

http://cloc.sourceforge.net v 1.53  T=8.0 s (202.4 files/s, 99198.6 lines/s)
-------------------------------------------------------------------------------
Language                     files          blank        comment           code
-------------------------------------------------------------------------------
Javascript                    1506          77848         212000         366495
CSS                             56           9671          20147          87695
HTML                            51           1409            151           7480
XML                              6           3088           1383           6222
-------------------------------------------------------------------------------
SUM:                          1619          92016         233681         467892
-------------------------------------------------------------------------------

Auf UNIX-ähnlichen Systemen gibt es ein Tool namens, clocdas Codestatistiken bereitstellt.

Ich bin auf ein zufälliges Verzeichnis in unserer Codebasis gestoßen, in dem steht:

      59 text files.
      56 unique files.                              
       5 files ignored.

http://cloc.sourceforge.net v 1.53  T=0.5 s (108.0 files/s, 50180.0 lines/s)
-------------------------------------------------------------------------------
Language                     files          blank        comment           code
-------------------------------------------------------------------------------
C                               36           3060           1431          16359
C/C++ Header                    16            689            393           3032
make                             1             17              9             54
Teamcenter def                   1             10              0             36
-------------------------------------------------------------------------------
SUM:                            54           3776           1833          19481
-------------------------------------------------------------------------------

Sie haben nicht angegeben, wie viele Dateien vorhanden sind oder welche Ausgabe gewünscht wird. Suchst du danach:

find . -name '*.php' | xargs wc -l

Noch eine Variation :)

$ find . -name '*.php' | xargs cat | wc -l

Bearbeiten: Dies ergibt die Gesamtsumme anstelle von Datei für Datei.

Edit2: Add .nach , findum es Arbeit

Überraschenderweise gibt es keine Antwort basierend auf Fund -execund awk. Auf geht's:

find . -type f -exec wc -l {} \; | awk '{ SUM += $0} END { print SUM }'

Dieses Snippet findet für alle Dateien ( -type f). Verwenden Sie zum Suchen nach Dateierweiterung -name:

find . -name '*.py' -exec wc -l '{}' \; | awk '{ SUM += $0; } END { print SUM; }'

Angenommen, Sie müssen Dateien mit unterschiedlichen Namenserweiterungen zählen (z. B. auch Eingeborene).

wc $(find . -type f | egrep "\.(h|c|cpp|php|cc)" )

Vielen Dank für das Feedback, ich habe es korrigiert.

POSIX

Im Gegensatz zu den meisten anderen Antworten funktionieren diese auf jedem POSIX-System, für eine beliebige Anzahl von Dateien und mit beliebigen Dateinamen (sofern nicht anders angegeben).

Zeilen in jeder Datei:

find . -name '*.php' -type f -exec wc -l {} \;
# faster, but includes total at end if there are multiple files
find . -name '*.php' -type f -exec wc -l {} +

Zeilen in jeder Datei, sortiert nach Dateipfad

find . -name '*.php' -type f | sort | xargs -L1 wc -l
# for files with spaces or newlines, use the non-standard sort -z
find . -name '*.php' -type f -print0 | sort -z | xargs -0 -L1 wc -l

Zeilen in jeder Datei, sortiert nach Anzahl der Zeilen, absteigend

find . -name '*.php' -type f -exec wc -l {} \; | sort -nr
# faster, but includes total at end if there are multiple files
find . -name '*.php' -type f -exec wc -l {} + | sort -nr

Gesamtzahl der Zeilen in allen Dateien

find . -name '*.php' -type f -exec cat {} + | wc -l

Es gibt ein kleines Tool namens sloccount, um die Codezeilen im Verzeichnis zu zählen. Es sollte beachtet werden, dass es mehr tut, als Sie möchten, da es leere Zeilen / Kommentare ignoriert, die Ergebnisse nach Programmiersprachen gruppiert und einige Statistiken berechnet.

Was Sie wollen, ist eine einfache forSchleife:

total_count=0
for file in $(find . -name *.php -print)
do
    count=$(wc -l $file)
    let total_count+=count
done
echo "$total_count"

Nur für Quellen:

wc `find`

Zum Filtern verwenden Sie einfach grep

wc `find | grep .php$`

Eine unkomplizierte Version, die schnell ist, die gesamte Such- / Filterleistung von nutzt find, nicht fehlschlägt, wenn zu viele Dateien vorhanden sind (Überlauf der Zahlenargumente), funktioniert einwandfrei mit Dateien mit lustigen Symbolen im Namen, ohne zu verwenden xargs, startet a nicht nutzlos hohe Anzahl externer Befehle (danke +für find's -exec). Bitte schön:

find . -name '*.php' -type f -exec cat -- {} + | wc -l

Ich weiß, dass die Frage als markiert ist Bash, aber es scheint, dass das Problem, das Sie lösen möchten, auch mit PHP zusammenhängt.

Sebastian Bergmann hat ein Tool namens PHPLOC geschrieben , das macht, was Sie wollen, und bietet Ihnen darüber hinaus einen Überblick über die Komplexität eines Projekts. Dies ist ein Beispiel für seinen Bericht:

Size
  Lines of Code (LOC)                            29047
  Comment Lines of Code (CLOC)                   14022 (48.27%)
  Non-Comment Lines of Code (NCLOC)              15025 (51.73%)
  Logical Lines of Code (LLOC)                    3484 (11.99%)
    Classes                                       3314 (95.12%)
      Average Class Length                          29
      Average Method Length                          4
    Functions                                      153 (4.39%)
      Average Function Length                        1
    Not in classes or functions                     17 (0.49%)

Complexity
  Cyclomatic Complexity / LLOC                    0.51
  Cyclomatic Complexity / Number of Methods       3.37

Wie Sie sehen, sind die bereitgestellten Informationen aus Sicht eines Entwicklers viel nützlicher, da sie Ihnen ungefähr sagen können, wie komplex ein Projekt ist, bevor Sie mit der Arbeit beginnen.

Vermutlich wird niemand dies jemals im Hintergrund begraben sehen ... Doch keine der bisherigen Antworten befasst sich mit dem Problem von Dateinamen mit Leerzeichen. Darüber hinaus können alle Verwendungszwecke xargsfehlschlagen, wenn die Gesamtlänge der Pfade im Baum die Größenbeschränkung für die Shell-Umgebung überschreitet (unter Linux standardmäßig einige Megabyte). Hier ist eine, die diese Probleme auf ziemlich direkte Weise behebt. Die Subshell kümmert sich um Dateien mit Leerzeichen. Die awkSumme ergibt den Stream der einzelnen Dateiausgaben wc, daher sollte niemals der Speicherplatz ausgehen. Es beschränkt auch nur die execDateien (Überspringen von Verzeichnissen):

find . -type f -name '*.php' -exec bash -c 'wc -l "$0"' {} \; | awk '{s+=$1} END {print s}' 

WC -L? Verwenden Sie besser GREP -C ^

wc -l? Falsch! Der Befehl wc zählt neue Zeilencodes, keine Zeilen! Wenn die letzte Zeile in der Datei nicht mit einem neuen Zeilencode endet, wird dies nicht gezählt!

Wenn Sie weiterhin Zeilen zählen möchten, verwenden Sie grep -c ^ , vollständiges Beispiel:

#this example prints line count for all found files
total=0
find /path -type f -name "*.php" | while read FILE; do
     #you see use grep instead wc ! for properly counting
     count=$(grep -c ^ < "$FILE")
     echo "$FILE has $count lines"
     let total=total+count #in bash, you can convert this for another shell
done
echo TOTAL LINES COUNTED:  $total

Achten Sie zum Schluss auf die wc-l-Falle ( Anzahl der Eingaben , keine Zeilen !!!)

Mit zsh globs ist das ganz einfach:

wc -l ./**/*.php

Wenn Sie bash verwenden, müssen Sie nur ein Upgrade durchführen. Es gibt absolut keinen Grund, Bash zu verwenden.

sehr einfach

find /path -type f -name "*.php" | while read FILE
do
    count=$(wc -l < $FILE)
    echo "$FILE has $count lines"
done

Wenn Sie möchten, dass Ihre Ergebnisse nach Anzahl der Zeilen sortiert werden, können Sie einfach | sortoder | sort -r( -rin absteigender Reihenfolge) zur ersten Antwort hinzufügen , wie folgt :

find . -name '*.php' | xargs wc -l | sort -r

Für Windows ist LocMetrics ein einfaches und schnelles Tool .

Etwas anderes:

wc -l `tree -if --noreport | grep -e'\.php$'`

Dies funktioniert einwandfrei, aber Sie müssen mindestens eine *.phpDatei im aktuellen Ordner oder einem seiner Unterordner haben, sonst wcbleibt sie stehen

Wenn Sie unter Linux arbeiten (und ich nehme an, Sie sind es), empfehle ich mein Tool polyglot . Es ist dramatisch schneller als entweder sloccountoder clocund es ist nützlicher als sloccount.

Sie können es mit aufrufen

poly .

oder

poly

Es ist also viel benutzerfreundlicher als ein kompliziertes Bash-Skript.

Das Tool Tokei zeigt Statistiken zum Code in einem Verzeichnis an. Tokei zeigt die Anzahl der Dateien, die Gesamtzahl der Zeilen in diesen Dateien und den Code, Kommentare und Leerzeichen nach Sprache gruppiert an. Tokei ist auch unter Mac, Linux und Windows verfügbar.

Ein Beispiel für die Ausgabe von Tokei lautet wie folgt:

$ tokei
-------------------------------------------------------------------------------
 Language            Files        Lines         Code     Comments       Blanks
-------------------------------------------------------------------------------
 CSS                     2           12           12            0            0
 JavaScript              1          435          404            0           31
 JSON                    3          178          178            0            0
 Markdown                1            9            9            0            0
 Rust                   10          408          259           84           65
 TOML                    3           69           41           17           11
 YAML                    1           30           25            0            5
-------------------------------------------------------------------------------
 Total                  21         1141          928          101          112
-------------------------------------------------------------------------------

Tokei kann installiert werden, indem Sie den Anweisungen in der README-Datei im Repository folgen .

Wenn Sie nur die Gesamtzahl der Zeilen in Ihren PHP-Dateien benötigen, können Sie auch unter Windows einen sehr einfachen einzeiligen Befehl verwenden, wenn Sie GnuWin32 installiert haben. So was:

cat `/gnuwin32/bin/find.exe . -name *.php` | wc -l

Sie müssen angeben, wo genau sich die find.exe befindet. Andernfalls wird die von Windows bereitgestellte FIND.EXE (aus den alten DOS-ähnlichen Befehlen) ausgeführt, da sie wahrscheinlich vor dem GnuWin32 in der Umgebung PATH liegt und unterschiedliche Parameter und Ergebnisse aufweist.

Bitte beachten Sie, dass Sie im obigen Befehl Anführungszeichen und keine einfachen Anführungszeichen verwenden sollten.

Geben Sie zuerst die längsten Dateien heraus (dh, diese langen Dateien müssen möglicherweise umgestaltet werden?), Und schließen Sie einige Herstellerverzeichnisse aus:

 find . -name '*.php' | xargs wc -l | sort -nr | egrep -v "libs|tmp|tests|vendor" | less

Wenn Sie es einfach halten möchten, schneiden Sie den Mittelsmann aus und rufen Sie einfach wcmit allen Dateinamen an:

wc -l `find . -name "*.php"`

Oder in der modernen Syntax:

wc -l $(find . -name "*.php")

Funktioniert, solange in keinem der Verzeichnisnamen oder Dateinamen Leerzeichen vorhanden sind. Und solange Sie nicht über Zehntausende von Dateien verfügen (moderne Shells unterstützen wirklich lange Befehlszeilen). Ihr Projekt verfügt über 74 Dateien, sodass Sie viel Platz zum Wachsen haben.

Sie brauchen nicht all diese komplizierten und schwer zu merkenden Befehle. Sie brauchen nur ein Werkzeug namens Zeilenzähler .

Ein kurzer Überblick

So erhalten Sie das Tool

$ pip install line-counter

Verwenden Sie den lineBefehl, um die Anzahl der Dateien und Zeilen im aktuellen Verzeichnis abzurufen (rekursiv).

$ line
Search in /Users/Morgan/Documents/Example/
file count: 4
line count: 839

Wenn Sie mehr Details wünschen, verwenden Sie einfach line -d.

$ line -d
Search in /Users/Morgan/Documents/Example/
Dir A/file C.c                                             72
Dir A/file D.py                                           268
file A.py                                                 467
file B.c                                                   32
file count: 4
line count: 839

Und das Beste an diesem Tool ist, dass Sie eine .gitignoreähnliche Konfigurationsdatei hinzufügen können. Sie können Regeln einrichten, um auszuwählen oder zu ignorieren, welche Art von Dateien gezählt werden sollen, genau wie in '.gitignore'.

Weitere Beschreibung und Verwendung finden Sie hier: https://github.com/MorganZhang100/line-counter

Wenn die Dateien zu viele sind, suchen Sie besser nach der Gesamtzahl der Zeilen.

find . -name '*.php' | xargs wc -l | grep -i ' total' | awk '{print $1}'

Zumindest unter OS X werden die in einigen anderen Antworten aufgeführten Befehle find + xarg + wc mehrmals in großen Listen mit "total" gedruckt, und es wird keine vollständige Summe angegeben. Mit dem folgenden Befehl konnte ich eine einzelne Summe für .c-Dateien abrufen:

find . -name '*.c' -print0 |xargs -0 wc -l|grep -v total|awk '{ sum += $1; } END { print "SUM: " sum; }'