Jak mogę zliczyć rekurencyjnie wszystkie linie kodu w katalogu?

Dla innej jedynki:

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

Działa na nazwach ze spacjami i wypisuje tylko jedną liczbę.

Jeśli używasz przyzwoicie najnowszej wersji Basha( lub ZSH), jest to znacznie prostsze:

wc -l **/*.php

W powłoce Bash wymaga to ustawienia opcji globstar, w przeciwnym razie operator glob nie jest rekurencyjny. Aby włączyć to ustawienie, wydaj

shopt -s globstar

Aby zrobić to stałe, dodaj je do jednego z plików inicjalizacyjnych(~/.bashrc, ~/.bash_profile itd.).

Możesz użyć cloc narzędzie, które jest zbudowane właśnie w tym celu. Raportuje ilość wierszy w każdym języku, wraz z ilością komentarzy itp. CLOC jest dostępny na systemach Linux, Mac i Windows.

Przykład użycia i wyjścia:

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

W systemach uniksopodobnych istnieje narzędzie o nazwie cloc, które dostarcza statystyki kodu.

Wpadłem na losowy katalog w naszej bazie kodu mówi:

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

Nie określiłeś, ile plików jest lub jakie jest pożądane wyjście.

To może być to, czego szukasz:

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

Kolejna odmiana:)

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

To da całkowitą sumę, zamiast pliku PO pliku.

Dodaj . po find, aby to działało.

Użyj Znajdź 'S -exec i awk. Zaczynamy:

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

Ten fragment znajduje dla wszystkich plików (-type f). Aby znaleźć według rozszerzenia pliku, użyj -name:

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

Bardziej powszechne i proste jak dla mnie, Załóżmy, że trzeba policzyć pliki z różnymi rozszerzeniami nazw (powiedzmy, również rodzimych):

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

POSIX

W przeciwieństwie do większości innych odpowiedzi tutaj, działają one na dowolnym systemie POSIX, dla dowolnej liczby plików i z dowolną nazwą plików (z wyjątkiem przypadków, w których zaznaczono).

Wiersze w każdym pliku:

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 {} +

Linie w każdym pliku, posortowane według ścieżki pliku

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

Wiersze w każdym pliku, posortowane według liczby wierszy, malejąco

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

Suma wierszy we wszystkich plikach

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

Istnieje małe narzędzie o nazwie sloccount aby policzyć wiersze kodu w katalogu.

Należy zauważyć, że robi więcej, niż chcesz, ponieważ ignoruje puste wiersze/komentarze, grupuje wyniki według języka programowania i oblicza pewne statystyki.

Chcesz prostej for pętli:

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

Tylko dla źródeł:

wc `find`

Aby filtrować, wystarczy użyć grep:

wc `find | grep .php$`

Prosty, który będzie szybki, wykorzysta całą moc wyszukiwania / filtrowania find, nie zawiedzie, gdy jest zbyt wiele plików( przepełnienie argumentów liczbowych), działa dobrze z plikami z zabawnymi symbolami w nazwie, bez użycia xargs i nie uruchomi bezużytecznie dużej liczby zewnętrznych poleceń (dzięki + dla find's -exec). Proszę bardzo:

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

Narzędzie Tokei wyświetla statystyki dotyczące kodu w katalogu. Tokei pokaże liczbę plików, całkowitą liczbę wierszy w tych plikach i Kod, komentarze i spacje pogrupowane według języka. Tokei jest również dostępny na komputerach Mac, Linux i Windows.

Przykład wyjścia Tokei jest następujący:

$ 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 można zainstalować, wykonując instrukcje na pliku README w repozytorium .

Wiem, że pytanie jest oznaczone jako bash , ale wydaje się, że problem, który próbujesz rozwiązać, jest również związany z PHP.

Sebastian Bergmann napisał narzędzie o nazwie PHPLOC , które robi to, co chcesz, a ponadto zapewnia przegląd złożoności projektu. To jest przykład jego raportu:

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

Jak widać, podane informacje są o wiele bardziej użyteczne z punktu widzenia dewelopera, ponieważ mogą z grubsza powiedzieć, jak skomplikowane projekt jest przed rozpoczęciem pracy z nim.

Żadna z odpowiedzi na dotychczasowy problem nazw plików ze spacjami.

Dodatkowo, wszystkie użyte xargs mogą nie działać, jeśli całkowita długość ścieżek w drzewie przekroczy limit rozmiaru środowiska powłoki (domyślnie kilka megabajtów w Linuksie).

Oto jeden, który rozwiązuje te problemy w dość bezpośredni sposób. Subshell zajmuje się plikami ze spacjami. awk sumuje strumień pojedynczych wyjść pliku wc, więc nigdy nie powinno zabraknąć miejsca. To także ograniczenie exec Tylko do plików (pomijanie katalogów):

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

WC-L ? lepiej używać GREP-C ^

wc -l? Źle!

Komenda wc liczy kody nowych linii, Nie linii! Gdy ostatni wiersz w pliku nie kończy się kodem nowej linii, nie będzie on liczony!

Jeśli nadal chcesz liczyć linie, użyj grep-C ^. Pełny przykład:

# 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 of '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

Na koniec uważaj na wc -l pułapkę (liczy wejścia, Nie linie!!!)

Dla Windows , łatwe i szybkie narzędzie jest LocMetrics.

Jeśli chcesz, aby wyniki były sortowane według liczby wierszy, możesz po prostu dodać | sort lub | sort -r (-r dla kolejności malejącej) do pierwszej odpowiedzi, w ten sposób:

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

Rozdawanie najpierw najdłuższych plików (tj. może te długie pliki potrzebują trochę refaktoryzującej miłości?), oraz z wyłączeniem niektórych katalogów dostawców:

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

Bardzo prosto:

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

Coś innego:

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

To działa dobrze, ale musisz mieć co najmniej jeden plik *.php w bieżącym folderze lub jednym z jego podfolderów, albo wc stragany.

To bardzo proste z z shell (zsh) globs:

wc -l ./**/*.php

Jeśli używasz Bash, wystarczy uaktualnić. Nie ma absolutnie żadnego powodu, aby używać Bash.

Możesz użyć narzędzia o nazwie codel (link ). Jest to prosty moduł Pythona do liczenia linii z kolorowym formatowaniem.

Instalacja

pip install codel

Użycie

Aby zliczyć linie plików C++ (z rozszerzeniami .cpp i .h), użyj:

codel count -e .cpp .h

Można również zignorować niektóre pliki / folder z .format gitignore:

codel count -e .py -i tests/**

Zignoruje wszystkie pliki w folderze tests/.

Wyjście wygląda następująco:

Możesz także skróć wyjście za pomocą znacznika -s. Ukryje informacje o każdym pliku i pokaże tylko informacje o każdym rozszerzeniu. Przykład znajduje się poniżej:

Jeśli plików jest za dużo, lepiej poszukać całkowitej liczby wierszy.

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

Jeśli potrzebujesz tylko całkowitej liczby linii w, powiedzmy, plikach PHP, możesz użyć bardzo prostego polecenia jednej linii nawet pod Windows, jeśli masz zainstalowany GnuWin32. Tak:

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

Musisz określić, gdzie dokładnie znajduje się znalezisko.exe w przeciwnym razie okna dostarczone znaleźć.EXE (ze starych komend podobnych do DOS) zostanie wykonane, ponieważ prawdopodobnie jest przed GnuWin32 w ścieżce środowiska i ma inne parametry i wyniki.

Należy pamiętać, że w polecenie powyżej powinieneś używać back-cudzysłowów, a nie pojedynczych cudzysłowów.

Chociaż lubię Skrypty, wolę ten, ponieważ pokazuje również podsumowanie na plik tak długo, jak całkowita:

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

Nie potrzebujesz tych wszystkich skomplikowanych i trudnych do zapamiętania poleceń. Potrzebujesz tylko Python narzędzie o nazwie line-counter .

Szybki przegląd

W ten sposób otrzymujesz narzędzie

$ pip install line-counter

Użyj polecenia line, aby uzyskać liczbę plików i linii pod bieżącym katalogiem (rekurencyjnie):

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

Jeśli chcesz więcej szczegółów, użyj 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

A najlepszą częścią tego narzędzia jest to, że możesz dodać plik konfiguracyjny podobny do .gitignore do to. Możesz skonfigurować reguły, aby wybrać lub zignorować, jakiego rodzaju pliki mają być policzone, tak jak to, co robisz w '.gitignore".

Więcej opisów i zastosowań jest tutaj: https://github.com/MorganZhang100/line-counter

Jeśli jesteś na Linuksie (i zakładam, że jesteś), polecam moje narzędzie polyglot . Jest znacznie szybszy niż sloccount lub cloc i jest bardziej funkcjonalny niż sloccount.

Możesz go wywołać za pomocą

poly .

Lub

poly

Więc jest o wiele bardziej przyjazny dla użytkownika niż jakiś zawiły skrypt Bash.