Jak rekurencyjnie policzyć wszystkie wiersze kodu w katalogu?

Mamy aplikację PHP i chcemy policzyć wszystkie wiersze kodu w określonym katalogu i jego podkatalogach. Nie musimy ignorować komentarzy, ponieważ staramy się tylko uzyskać ogólny pomysł.

wc -l *.php 

To polecenie działa świetnie w danym katalogu, ale ignoruje podkatalogi. Myślałem, że to może zadziałać, ale zwraca 74, co zdecydowanie nie jest przypadkiem ...

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

Jaka jest poprawna składnia dla wszystkich plików?

Próbować:

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

Narzędzie SLOCCount może również pomóc.

Zapewni to dokładne wiersze kodu źródłowego dla dowolnej hierarchii, na którą wskazujesz, a także dodatkowe statystyki.

Posortowane dane wyjściowe:

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

W przypadku kolejnej linijki:

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

działa na nazwach ze spacjami, wyświetla tylko jedną liczbę.

Jeśli używasz całkiem nowej wersji Bash (lub ZSH), jest to o wiele prostsze:

wc -l **/*.php

W powłoce Bash wymaga to ustawienia globstaropcji, w przeciwnym razie **operator globalny nie będzie rekurencyjny. Aby włączyć to ustawienie, problem

shopt -s globstar

Aby uczynić to na stałe, dodać go do jednego z plików inicjalizacji ( ~/.bashrc, ~/.bash_profileetc.).

Możesz użyć clocnarzędzia zbudowanego właśnie w tym celu. Podaje liczbę wierszy w każdym języku, a także liczbę komentarzy itp. CLOC jest dostępny w 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 typu UNIX istnieje narzędzie o nazwie, clocktóre zapewnia statystyki kodu.

Natknąłem się na losowy katalog w naszej bazie kodu:

      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ślono liczby plików ani żądanego wyniku. Czy tego szukasz:

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

Kolejna odmiana :)

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

Edycja: da całkowitą sumę zamiast pliku po pliku.

Edycja2: Dodaj .po, findaby to działało

Zaskakujące, że nie ma odpowiedzi w oparciu o find -execi awk. No to ruszamy:

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

Ten fragment znajduje się 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 musisz liczyć pliki o różnych rozszerzeniach nazw (np. Także tubylcy)

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

Dziękuję za informację zwrotną, poprawiłem ją.

POSIX

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

Linie 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

Linie w każdym pliku, posortowane według liczby linii, maleją

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

Łączna liczba wierszy we wszystkich plikach

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

Istnieje małe narzędzie o nazwie sloccount do zliczania linii kodu w katalogu. Należy zauważyć, że robi więcej, niż chcesz, ponieważ ignoruje puste linie / komentarze, grupuje wyniki według języka programowania i oblicza niektóre statystyki.

To, czego chcesz, to prosta forpętla:

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`

do filtrowania użyj po prostu 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 ze śmiesznymi symbolami w nazwie, bez użycia xargs, nie uruchomi niepotrzebnie duża liczba poleceń zewnętrznych (z uwagi +na find„e -exec). Proszę bardzo:

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

Wiem, że pytanie jest oznaczone jako grzmotnąć, 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 na dodatek zapewnia przegląd złożoności projektu. Oto 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ć, dostarczone informacje są o wiele bardziej przydatne z perspektywy dewelopera, ponieważ mogą z grubsza powiedzieć, jak skomplikowany jest projekt, zanim zaczniesz z nim pracować.

Zgaduję, że nikt nigdy nie zobaczy tego zakopanego z tyłu ... Jednak żadna z dotychczasowych odpowiedzi nie dotyczy problemu nazw plików ze spacjami. Ponadto wszystkie te zastosowania xargsmogą ulec awarii, jeśli całkowita długość ścieżek w drzewie przekroczy limit wielkości środowiska powłoki (domyślnie w Linuksie jest to kilka megabajtów). Oto jeden, który naprawia te problemy w dość bezpośredni sposób. Podpowłoka zajmuje się plikami ze spacjami. awkWynosi strumień poszczególnych plików wcwyjść, więc nigdy nie powinno zabraknąć miejsca. Ogranicza również exectylko 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żyj GREP -C ^

wc -l? Źle! polecenie wc zlicza nowe kody wierszy, a nie wiersze! Kiedy ostatni wiersz w pliku nie kończy się nowym kodem wiersza, nie zostanie to policzone!

jeśli nadal chcesz zliczać 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 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 pułapkę wc -l (liczy się wejścia, a nie wiersze !!!)

Zsh globs jest bardzo łatwe:

wc -l ./**/*.php

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

bardzo prosto

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

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

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

W systemie Windows łatwym i szybkim narzędziem jest LocMetrics .

Coś innego:

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

Działa to dobrze, ale musisz mieć co najmniej jeden *.phpplik w bieżącym folderze lub jednym z jego podfolderów, w przeciwnym razie wcprzeciągnie się

Jeśli korzystasz z Linuksa (i rozumiem, że tak), polecam moje narzędzie polyglot . Jest to znacznie szybciej niż którykolwiek sloccountalbo cloci to jest potężniejszy niż sloccount.

Możesz to wywołać za pomocą

poly .

lub

poly

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

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 komputery Mac, Linux i Windows.

Przykład danych wyjściowych 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ć, postępując zgodnie z instrukcjami w pliku README w repozytorium .

Jeśli potrzebujesz tylko całkowitej liczby wierszy, powiedzmy, że w twoich plikach PHP możesz użyć bardzo prostego polecenia w jednym wierszu, nawet pod Windows, jeśli masz zainstalowany GnuWin32. Lubię to:

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

Musisz określić, gdzie dokładnie jest find.exe, w przeciwnym razie zostanie uruchomiony FIND.EXE dostarczony przez system Windows (ze starych poleceń podobnych do DOS), ponieważ prawdopodobnie znajduje się on przed GnuWin32 w ścieżce środowiska i ma inne parametry i wyniki.

Pamiętaj, że w powyższym poleceniu powinieneś używać cudzysłowu, a nie pojedynczych cudzysłowów.

Rozdawanie najpierw najdłuższych plików (np. Może te długie pliki wymagają trochę refaktoryzacji?) I wykluczanie niektórych katalogów dostawców:

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

Jeśli chcesz to uprościć, odetnij pośrednika i po prostu zadzwoń wcze wszystkimi nazwami plików:

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

Lub w nowoczesnej składni:

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

Działa, dopóki w nazwach katalogów lub nazw plików nie ma spacji. I dopóki nie masz dziesiątek tysięcy plików (nowoczesne powłoki obsługują naprawdę długie wiersze poleceń). Twój projekt ma 74 pliki, więc masz dużo miejsca na rozwój.

Nie potrzebujesz wszystkich tych skomplikowanych i trudnych do zapamiętania poleceń. Potrzebujesz tylko narzędzia o nazwie licznik linii .

Szybki przegląd

W ten sposób otrzymujesz narzędzie

$ pip install line-counter

Użyj linepolecenia, aby uzyskać liczbę plików i liczbę wierszy w bieżącym katalogu (rekurencyjnie)

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

Jeśli chcesz uzyskać więcej szczegółów, po prostu 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 najlepsze jest to, że możesz dodać .gitignoredo niego plik konfiguracyjny. Możesz skonfigurować reguły, aby wybierać lub ignorować rodzaj plików do zliczenia, tak jak robisz to w „.gitignore”.

Więcej opisu i zastosowania znajduje się tutaj: https://github.com/MorganZhang100/line-counter

Jeśli plików jest za dużo, lepiej po prostu sprawdzić całkowitą liczbę wierszy.

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

Przynajmniej w systemie OS X komendy find + xarg + wc wymienione w niektórych innych odpowiedziach drukują „total” kilka razy na dużych listach i nie podano pełnej sumy. Byłem w stanie uzyskać jedną sumę dla plików .c za pomocą następującego polecenia:

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