Wie kann man alle Codezeilen in einem Verzeichnis rekursiv zählen?

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 finds -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: 

1. mit find -exec , 
2. mit einfügen (mit Schnitt) , 
3. mit bc  

$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:

1. Schließt Pfade aus, die nicht Ihr Code sind (von find überhaupt nicht durchlaufen)
2. Filtert zusammengesetzte Erweiterungen und andere Dateien heraus, die Sie ignorieren möchten
3. Enthält nur tatsächliche Dateien der von Ihnen angegebenen Typen
4. Ignoriert Leerzeilen
5. Gibt eine einzelne Zahl insgesamt

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