Wir haben eine Anwendung PHP und möchten alle Codezeilen unter einem bestimmten Verzeichnis und dessen Unterverzeichnissen zählen. Wir müssen keine Kommentare ignorieren, da wir nur versuchen, eine ungefähre Vorstellung zu bekommen.
wc -l *.php
Dieser Befehl funktioniert gut in einem bestimmten Verzeichnis, ignoriert jedoch Unterverzeichnisse. Ich dachte, das könnte funktionieren, aber es wird 74 zurückkehren, was definitiv nicht der Fall ist ...
find . -name '*.php' | wc -l
Wie lautet die korrekte Syntax für alle Dateien?
Versuchen:
find . -name '*.php' | xargs wc -l
Das SLOCCount-Tool kann ebenfalls hilfreich sein.
Es gibt eine genaue Quellcodezeile für die Hierarchie, auf die Sie es zeigen, sowie einige zusätzliche Statistiken.
Für einen anderen Einliner:
( find ./ -name '*.php' -print0 | xargs -0 cat ) | wc -l
arbeitet mit Namen mit Leerzeichen, gibt nur eine Zahl aus.
Wenn Sie eine anständig neuere Version von Bash (oder ZSH) verwenden, ist dies viel einfacher:
wc -l **/*.php
In der Bash Shell muss dazu die Option globstar
gesetzt sein, andernfalls ist der **
glob-Operator nicht rekursiv. Um diese Einstellung zu aktivieren, geben Sie Folgendes ein
shopt -s globstar
Um dies dauerhaft zu machen, fügen Sie es einer der Initialisierungsdateien hinzu (~/.bashrc
, ~/.bash_profile
usw.).
Sie können das Dienstprogramm cloc
verwenden, das genau zu diesem Zweck erstellt wurde. Es meldet jeweils die Anzahl der Zeilen in jeder Sprache, zusammen mit der Anzahl der Kommentare usw. 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 cloc
, das Codestatistiken bereitstellt.
Ich lief in einem zufälligen Verzeichnis in unserer Code-Basis:
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 wie die gewünschte Ausgabe aussehen soll.
find . -name '*.php' | xargs wc -l
Noch eine andere Variante :)
$ find -name '*.php' | xargs cat | wc -l
Bearbeiten: Hier wird die Gesamtsumme anstelle von Datei für Datei angezeigt.
POSIX
Anders als die 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
Zeilen in allen Dateien
find . -name '*.php' -type f -exec cat {} + | wc -l
Häufiger und einfacher als bei mir, nehmen Sie an, Sie müssen Dateien verschiedener Namenserweiterungen zählen (zB auch Eingeborene).
wc `find . -name '*.[h|c|cpp|php|cc]'`
Es gibt ein kleines Werkzeug 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 pro Programmiersprache gruppiert und einige Statistiken berechnet.
Überraschenderweise gibt es keine Antwort, basierend auf -exec
und awk
von find. Auf geht's:
find . -type f -exec wc -l {} \; | awk '{ SUM += $0} END { print SUM }'
Dieser Ausschnitt sucht nach allen Dateien (-type f
). Um nach Dateierweiterung zu suchen, verwenden Sie -name
:
find . -name *.py -exec wc -l {} \; | awk '{ SUM += $0} END { print SUM }'
nur für Quellen:
wc `find`
zum filtern benutzen sie einfach grep
wc `find | grep .php$`
Eine unkomplizierte Datei, die schnell sein wird, wird die gesamte Such-/Filterleistung von find
verwenden, nicht fehlschlagen, wenn zu viele Dateien vorhanden sind (Zahlargumente überlaufen). Sie funktioniert gut mit Dateien mit lustigen Symbolen im Namen. xargs
wird nicht verwendet Starten Sie eine unbrauchbar hohe Anzahl externer Befehle (dank +
für find
s -exec
). Bitte schön:
find . -name '*.php' -type f -exec cat -- {} + | wc -l
Was Sie wollen, ist eine einfache for
-Schleife:
total_count=0
for file in $(find . -name *.php -print)
do
count=$(wc -l $file)
let total_count+=count
done
echo "$total_count"
Erraten wird niemand, dass dies auf der Rückseite vergraben wird ... Trotzdem kommt keine der bisherigen Antworten auf das Problem der Dateinamen mit Leerzeichen. Darüber hinaus können alle, die xargs
verwenden, fehlschlagen, wenn die Gesamtlänge der Pfade in der Baumstruktur den Grenzwert für die Shell-Umgebungsgröße überschreitet (in Linux beträgt der Standardwert einige MB). Hier ist einer, der diese Probleme auf eine ziemlich direkte Weise behebt. Die Subshell kümmert sich um Dateien mit Leerzeichen. Die Variable awk
ist der Gesamtstrom der Ausgaben der einzelnen Datei wc
. Daher sollte der Speicherplatz nie ausgehen. Es beschränkt auch die exec
auf Dateien (Verzeichnisse überspringen):
find . -type f -name '*.php' -exec bash -c 'wc -l "$0"' {} \; | awk '{s+=$1} END {print s}'
Ich weiß, dass die Frage als bash markiert ist, aber es scheint, dass das Problem, das Sie zu lösen versuchen, auch mit PHP zusammenhängt.
Sebastian Bergmann hat ein Tool namens PHPLOC geschrieben, das das tut, was Sie möchten, und darüber hinaus erhalten Sie 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 der Sicht eines Entwicklers viel nützlicher, da sie Ihnen grob sagen können, wie komplex ein Projekt ist, bevor Sie damit beginnen.
WC -L? Verwenden Sie besser GREP -C ^
wc -l? Falsch! Der Befehl wc zählt neue Zeilencodes, nicht Zeilen! Wenn die letzte Zeile in der Datei nicht mit einem neuen Zeilencode endet, wird nicht gezählt!
wenn Sie noch Zeilen zählen möchten, verwenden Sie grep -c ^.
#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 schließlich auf die wc -l-Falle (Zählungen, nicht 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.
Wenn Sie möchten, dass Ihre Ergebnisse nach der Anzahl der Zeilen sortiert werden, können Sie der ersten Antwort einfach | sort
oder | sort -r
(-r
für absteigende Reihenfolge) hinzufügen.
find . -name '*.php' | xargs wc -l | sort -r
Was anderes:
wc -l `tree -if --noreport | grep -e'\.php$'`
Das funktioniert gut, aber Sie müssen mindestens eine *.php
-Datei im aktuellen Ordner oder einem seiner Unterordner haben, oder wc
bleibt stehen
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 die find.exe ist. Andernfalls wird das von Windows bereitgestellte FIND.EXE (von den alten DOS-ähnlichen Befehlen) ausgeführt, da es wahrscheinlich vor GnuWin32 in der Umgebung PATH liegt und unterschiedliche Parameter und Ergebnisse aufweist.
Bitte beachten Sie, dass Sie in dem Befehl oben Anführungszeichen verwenden sollten, keine einfachen Anführungszeichen.
Erstes Ausgeben der längsten Dateien (dh, möglicherweise benötigen diese langen Dateien Refactoring-Liebe?) Und einige Herstellerverzeichnisse ausgeschlossen
find . -name '*.php' | xargs wc -l | sort -nr | egrep -v "libs|tmp|tests|vendor" | less
Für Windows ist LocMetrics ein einfaches und schnelles Werkzeug.
ich mag die Skripte zwar, aber ich bevorzuge dieses Skript, da es auch eine Zusammenfassung pro Datei enthält, solange es insgesamt ist
wc -l `find . -name "*.php"`
Leere Zeile ausschließen
find . -name "*.php" | xargs grep -v -c '^$' | awk 'BEGIN {FS=":"} { $cnt = $cnt + $2} END {print $cnt}'
Leerzeilen inklusive:
find . -name "*.php" | xargs wc -l
Sie brauchen nicht all diese komplizierten und schwer zu merkenden Befehle. Sie brauchen nur ein Werkzeug namens line-counter.
Ein kurzer Überblick
So erhalten Sie das Tool
$ pip install line-counter
Verwenden Sie den Befehl line
, um die Anzahl der Dateien und der Zeilen unter dem aktuellen Verzeichnis (rekursiv) abzurufen.
$ 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 .gitignore
wie Konfigurationsdatei hinzufügen können. Sie können Regeln einrichten, um auszuwählen oder zu ignorieren, welche Art von Dateien genau wie bei ".gitignore" zählt.
Weitere Beschreibung und Verwendung finden Sie hier: https://github.com/MorganZhang100/line-counter
Zumindest unter OS X werden die Befehle find + xarg + wc, die in einigen anderen Antworten aufgelistet sind, mehrmals "total" in großen Listen ausgegeben, und es wird keine vollständige Summe angegeben. Ich konnte mit dem folgenden Befehl eine einzige Summe für .c-Dateien erhalten:
find . -name '*.c' -print0 |xargs -0 wc -l|grep -v total|awk '{ sum += $1; } END { print "SUM: " sum; }'
Wenn Sie es einfach halten möchten, schneiden Sie den Mittelsmann aus und rufen Sie einfach wc
mit allen Dateinamen auf:
wc -l `find . -name "*.php"`
Oder in der modernen Syntax:
wc -l $(find . -name "*.php")
Funktioniert, solange in den Verzeichnisnamen oder Dateinamen keine Leerzeichen stehen. Und solange Sie keine Zehntausende von Dateien haben (moderne Shells unterstützen wirklich lange Befehlszeilen). Ihr Projekt hat 74 Dateien, so dass Sie viel Platz zum Wachsen haben.
Wenn Sie unter Linux sind (und ich nehme an, Sie sind es), empfehle ich mein Tool polyglot . Es ist dramatisch schneller als sloccount
oder cloc
und es ist mehr als sloccount
.
Sie können es mit aufrufen
poly .
oder
poly
es ist also viel benutzerfreundlicher als ein gewundenes Bash-Skript.
Ich habe dieses Inline-Skript verwendet, das ich aus dem Verzeichnis von src-project starte:
for i in $(find . -type f); do rowline=$(wc -l $i | cut -f1 -d" "); file=$(wc -l $i | cut -f2 -d" "); lines=$((lines + rowline)); echo "Lines["$lines"] " $file "has "$rowline"rows."; done && unset lines
Das erzeugt diese Ausgabe:
Lines[75] ./Db.h has 75rows.
Lines[143] ./Db.cpp has 68rows.
Lines[170] ./main.cpp has 27rows.
Lines[294] ./Sqlite.cpp has 124rows.
Lines[349] ./Sqlite.h has 55rows.
Lines[445] ./Table.cpp has 96rows.
Lines[480] ./DbError.cpp has 35rows.
Lines[521] ./DbError.h has 41rows.
Lines[627] ./QueryResult.cpp has 106rows.
Lines[717] ./QueryResult.h has 90rows.
Lines[828] ./Table.h has 111rows.
Ich wollte mehrere Dateitypen überprüfen und war zu faul, die Gesamtmenge von Hand zu berechnen. Also verwende ich dies jetzt, um die Gesamtsumme auf einen Schlag zu erhalten.
find . -name '*.js' -or -name '*.php' | xargs wc -l | grep 'total' | awk '{ SUM += $1; print $1} END { print "Total text lines in PHP and JS",SUM }'
79351
15318
Textzeilen insgesamt in PHP und JS 94669
Auf diese Weise können Sie mehrere Erweiterungstypen verketten, nach denen Sie filtern möchten. Fügen Sie sie einfach in den -name '*.js' -or -name '*.php'
-Teil ein und ändern Sie möglicherweise die otuput-Nachricht nach Ihren Wünschen
Ändern Sie zunächst das Verzeichnis, in dem Sie die Anzahl der Zeilen erfahren möchten. Zum Beispiel, wenn ich die Zeilenanzahl in allen Dateien des Verzeichnisses sample wissen möchte. $cd sample
geben. Dann versuchen Sie den Befehl $wc -l *
. Dies gibt die Anzahl der Zeilen für jede Datei und auch die Gesamtzahl der Zeilen im gesamten Verzeichnis am Ende zurück
Noch ein Befehl, um die Summe aller Dateien zu erhalten (natürlich Linux)
find ./ -type f -exec wc -l {} \; | cut -d' ' -f1 | paste -sd+ | bc
Hauptunterschied zu anderen Antworten:
$cd directory
$wc -l* | sort -nr
sehr einfach
find /path -type f -name "*.php" | while read FILE
do
count=$(wc -l < $FILE)
echo "$FILE has $count lines"
done
Ich habe auf meinem Windows-System eine Box installiert. Also hier ist was ich getan habe.
ECHO OFF
for /r %%G in (*.php) do (
busybox grep . "%%G" | busybox wc -l
)
So mach ich es:
hier ist die Implementierung der lineCount.c-Datei:
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int getLinesFromFile(const char*);
int main(int argc, char* argv[]) {
int total_lines = 0;
for(int i = 1; i < argc; ++i) {
total_lines += getLinesFromFile(argv[i]); // *argv is a char*
}
printf("You have a total of %d lines in all your file(s)\n", total_lines);
return 0;
}
int getLinesFromFile(const char* file_name) {
int lines = 0;
FILE* file;
file = fopen(file_name, "r");
char c = ' ';
while((c=getc(file)) != EOF) if(c == '\n') ++lines;
fclose(file);
return lines;
}
Öffnen Sie nun die Befehlszeile:
geben Sie gcc lineCount.c
ein, und geben Sie ./a.out *.txt
____ ein. Dadurch werden die Gesamtzeilen von Dateien angezeigt, die in Ihrem Verzeichnis mit.
Ähnlich wie Shizzmos Antwort , aber hässlicher und genauer. Wenn Sie es häufig verwenden, passen Sie es an und fügen Sie es in ein Skript ein.
Dieses Beispiel:
find
überhaupt nicht durchlaufen)find . \! \( \( -path ./lib -o -path ./node_modules -o -path ./vendor -o -path ./any/other/path/to/skip -o -wholename ./not/this/specific/file.php -o -name '*.min.js' -o -name '*.min.css' \) -Prune \) -type f \( -name '*.php' -o -name '*.inc' -o -name '*.js' -o -name '*.scss' -o -name '*.css' \) -print0 | xargs -0 cat | grep -v '^$' | wc -l
Hier ist eine flexible Version mit älterem Python (funktioniert in mindestens Python 2.6), die @ Shizzmos hübschen Einzeiler enthält. Füllen Sie einfach die Liste types
mit den Dateitypen aus, die im Quellordner gezählt werden sollen, und lassen Sie es los:
#!/usr/bin/python
import subprocess
rcmd = "( find ./ -name '*.%s' -print0 | xargs -0 cat ) | wc -l"
types = ['c','cpp','h','txt']
sum = 0
for el in types:
cmd = rcmd % (el)
p = subprocess.Popen([cmd],stdout=subprocess.PIPE,Shell=True)
out = p.stdout.read().strip()
print "*.%s: %s" % (el,out)
sum += int(out)
print "sum: %d" % (sum)
Wenn die Dateien zu viele sind, sollten Sie einfach nach der Gesamtzahl der Zeilen suchen.
find . -name '*.php' | xargs wc -l | grep -i ' total' | awk '{print $1}'
cat \`find . -name "*.php"\` | wc -l
Ich kann auch einen anderen OS X-Eintrag hinzufügen, der einfach altes Suchen mit exec verwendet (was ich lieber als xargs benutze, da ich ungerade Ergebnisse von sehr großen find
Ergebnismengen mit xargs in der Vergangenheit gesehen habe). Da dies für OS X ist, habe ich auch die .h- oder .m-Datei in die Filterung eingefügt. Kopieren Sie sie bitte bis zum Ende!
find ./ -type f -name "*.[mh]" -exec wc -l {} \; | sed -e 's/[ ]*//g' | cut -d"." -f1 | paste -sd+ - | bc