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 -lJaka jest poprawna składnia dla wszystkich plików?
Odpowiedzi:
Próbować:
find . -name '*.php' | xargs wc -lNarzę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
find . -name '*.php' -o -name '*.inc' | xargs wc -l
wcbędzie uruchamiany wiele razy. Nie obsługuje także wielu specjalnych nazw plików.
find . -name "*.php" -not -path "./tests*" | xargs wc -l
W przypadku kolejnej linijki:
( find ./ -name '*.php' -print0 | xargs -0 cat ) | wc -ldziała na nazwach ze spacjami, wyświetla tylko jedną liczbę.
man find.. print0 z xargs -0 pozwala operować na plikach, które mają spacje lub inne dziwne znaki w swojej nazwie
( find . \( -name '*.h' -o -name '*.cpp' \) -print0 | xargs -0 cat ) | wc -l
Jeśli używasz całkiem nowej wersji Bash (lub ZSH), jest to o wiele prostsze:
wc -l **/*.phpW powłoce Bash wymaga to ustawienia globstaropcji, w przeciwnym razie **operator globalny nie będzie rekurencyjny. Aby włączyć to ustawienie, problem
shopt -s globstarAby uczynić to na stałe, dodać go do jednego z plików inicjalizacji ( ~/.bashrc, ~/.bash_profileetc.).
globstarAby to działało, należy ustawić Bash .
wc -l **/*.[ch]znajduje w sumie 15195373 wierszy. Nie jestem pewien, czy uważasz to za „bardzo niską wartość”. Ponownie musisz upewnić się, że masz globstarwłączony Bash. Możesz to sprawdzić za pomocą shopt globstar. Aby to wyraźnie włączyć, wykonaj shopt -s globstar.
ARG_MAXjeśli masz dużą liczbę .phpplików, ponieważ wcnie jest wbudowane.
findzawierają spacje. Można to naprawić za pomocą print0i --nullprzy pomocy wywołań findi xargs.
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
-------------------------------------------------------------------------------clocjest to platforma wieloplatformowa, ponieważ jest to tylko skrypt Perla?
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 -lgo () { mkdir /tmp/go; [[ -f ./"$1" ]] && mv ./"$1" /tmp/go; (find ./ -type f -name "$*" -print0 | xargs -0 cat ) | wc -l; wc -l /tmp/go/*; mv /tmp/go/* . } Wyniki były zbliżone do slocount za *.py, ale nie wiem *.js, *.html.
Kolejna odmiana :)
$ find . -name '*.php' | xargs cat | wc -lEdycja: da całkowitą sumę zamiast pliku po pliku.
Edycja2: Dodaj .po, findaby to działało
$ find -name \*\.php -print0 | xargs -0 cat | wc -l
find . -name '*.php' | xargs cat | wc -l... podczas gdy daje to plik po pliku i wielką sumę:find . -name '*.php' | xargs wc -l
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; }'find . -name '*.c' -print0 |xargs -0 wc -l. To powiedziawszy, ta szybsza metoda (przynajmniej w OS X) powoduje kilkakrotne wydrukowanie „sumy”, więc wymagane jest dodatkowe filtrowanie, aby uzyskać odpowiednią sumę (opublikowałem szczegóły w mojej odpowiedzi).
wcw formie a catjest powolne, ponieważ system musi najpierw przetworzyć wszystkie GB, aby rozpocząć zliczanie wierszy (testowany z 200 GB plików jsons, 12k plików). zrobienie wcnajpierw, a następnie policzenie wyniku jest znacznie szybsze
find . -type f -exec wc -l {} \+lub find . -name '*.py' -type f -exec wc -l {} \+ który wypisuje sumę na końcu wyniku. Jeśli interesuje Cię tylko suma, możesz pójść o krok dalej i użyć tail: find . -type f -exec wc -l {} \+ | tail -1lubfind . -name '*.py' -type f -exec wc -l {} \+ | tail -1
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 -lLinie 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 -lIstnieje 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"xargs?
IFS=$'\n'przed pętlą przynajmniej poprawiłoby to dla wszystkich oprócz plików z nazwami nowej linii. Po drugie, nie cytujesz '*.php', więc zostanie on rozszerzony przez powłokę, a nie find, a ergo nie znajdzie żadnego pliku php w podkatalogach. Również -printjest zbędne, ponieważ sugeruje się brak innych działań.
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\;zamiast tego, +że nie byłem tego świadomy), ta odpowiedź powinna być poprawna.
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.37Jak 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: $totalna koniec uważaj na pułapkę wc -l (liczy się wejścia, a nie wiersze !!!)
grep -c ^liczysz liczbę niekompletnych linii , a takie niekompletne linie nie mogą pojawić się w pliku tekstowym .
find -type f -name '*.php' -print0 | xargs -0 grep -ch ^ | paste -sd+ - | bcbc
Zsh globs jest bardzo łatwe:
wc -l ./**/*.phpJeś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"
doneJeś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 -rxargs wc -lsą liczbowe, należałoby użyć sort -nlub sort -nr.
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
polywię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 -lMusisz 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.
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.
wc -l `find . -type f \( -name "*.cpp" -o -name "*.c" -o -name "*.h" \) -print`
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-counterUż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: 839Jeś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: 839A 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
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; }'