it-swarm.com.de

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

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? 

1384
user77413

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.

2340
Peter Elespuru

Für einen anderen Einliner:

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

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

420
Shizzmo

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.).

363
Michael Wild

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
-------------------------------------------------------------------------------
264
simao

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
-------------------------------------------------------------------------------
91
Calmarius

Sie haben nicht angegeben, wie viele Dateien vorhanden sind oder wie die gewünschte Ausgabe aussehen soll.

find . -name '*.php' | xargs wc -l
32
Paweł Polewicz

Noch eine andere Variante :)

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

Bearbeiten: Hier wird die Gesamtsumme anstelle von Datei für Datei angezeigt.

21

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
20
Paul Draper

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]'`
18
sergeych

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.

17
sebasgo

Ü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 }'
16
jonhattan

nur für Quellen:

wc `find`

zum filtern benutzen sie einfach grep

wc `find | grep .php$`
11
kekszumquadrat

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
11
gniourf_gniourf

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"
11
ennuikiller

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}' 
8
Gene

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.

7
Ja͢ck

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 !!!)

5
Znik

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.

4
HappyFace

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
4
Paul Pettengill

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

4
nav

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.

3
Neven Boyanov

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
3
Matt

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

3
walv

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"`
2
akiva

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
2

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

2
Morgan Zhang

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; }'

2
Doug Richardson

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.

2
alexis

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.

2
user8174234

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.
2
Luca Davanzo

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

1
Tschallacka

Ä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

1
venky513

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  
1
AJed
$cd directory
$wc -l* | sort -nr
1
sree

sehr einfach

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

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
) 
1
shyam

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.

1
Moshe Rabaev

Ä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
0
Walf

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)
0
fyngyrz

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}'
0
bharath
cat \`find . -name "*.php"\` | wc -l
0

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