We hebben een PHP-applicatie en willen alle regels code tellen onder een specifieke map en zijn subdirectories.
We hoeven geen opmerkingen te negeren, want we proberen gewoon een ruw idee te krijgen.
wc -l *.php
Die opdracht werkt geweldig voor een gegeven map, maar het negeert submappen. Ik dacht dat de volgende opmerking zou kunnen werken, maar het retourneert 74, wat zeker niet het geval is …
find . -name '*.php' | wc -l
Wat is de juiste syntaxis om in alle bestanden van een map opnieuw te voeden?
1, Autoriteit 100%
Probeer:
find . -name '*.php' | xargs wc -l
of (wanneer bestandsnamen speciale tekens zoals spaties bevatten)
find . -name '*.php' | sed 's/.*/"&"/' | xargs wc -l
Het slibcount-tool kan ook helpen.
Het geeft een nauwkeurige bronlijnen van codeltelling voor wat dan ook
Hiërarchie waar je het op wijzen, evenals enkele extra statistieken.
Sorted Output:
find . -name '*.php' | xargs wc -l | sort -nr
2, Autoriteit 18%
Voor een andere one-liner:
( find ./ -name '*.php' -print0 | xargs -0 cat ) | wc -l
Het werkt op namen met spaties en voert slechts één cijfer uit.
3, Autoriteit 15%
Als je een redelijk recente versie van Bash (of ZSH) gebruikt, is het veel eenvoudiger:
wc -l **/*.php
In de Bash-shell vereist dit dat de optie globstaris ingesteld, anders is de glob-operator **niet recursief. Om deze instelling in te schakelen, probleem
shopt -s globstar
Om dit permanent te maken, voegt u het toe aan een van de initialisatiebestanden (~/.bashrc, ~/.bash_profileenz.).
Antwoord 4, autoriteit 15%
U kunt het hulpprogramma clocgebruiken dat voor dit exacte doel is gebouwd . Het rapporteert elk het aantal regels in elke taal, samen met het aantal opmerkingen, enz. CLOC is beschikbaar op Linux, Mac en Windows.
Gebruiks- en uitvoervoorbeeld:
$ 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
-------------------------------------------------------------------------------
Antwoord 5, autoriteit 4%
Op Unix-achtige systemen is er een tool genaamd clocdie codestatistieken levert.
Ik kwam een willekeurige map tegen in onze codebasis, er staat:
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
-------------------------------------------------------------------------------
Antwoord 6
Je hebt niet aangegeven hoeveel bestanden er zijn of wat de gewenste uitvoer is.
Dit is misschien wat u zoekt:
find . -name '*.php' | xargs wc -l
7
Nieuwe en eenvoudiger als voor mij, stel dat u bestanden van verschillende naamextensies nodig hebt (zeg, ook inboorlingen):
wc $(find . -type f | egrep "\.(h|c|cpp|php|cc)" )
8
posix
In tegenstelling tot de meeste andere antwoorden hier, werken deze werkzaamheden op elk POSIX-systeem, voor een willekeurig aantal bestanden en met eventuele bestandsnamen (behalve waar vermeld).
Lijnen in elk bestand:
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 {} +
Lijnen in elk bestand, gesorteerd op bestandspad
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
Lijnen in elk bestand, gesorteerd op aantal lijnen, aflopend
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
Totaal aantal regels in alle bestanden
find . -name '*.php' -type f -exec cat {} + | wc -l
Antwoord 9
Er is een kleine tool genaamd sloccountom de regels te tellen van code in een directory.
Opgemerkt moet worden dat het meer doet dan u wilt, omdat het lege regels/opmerkingen negeert, de resultaten per programmeertaal groepeert en enkele statistieken berekent.
Antwoord 10
U wilt een eenvoudige for-lus:
total_count=0
for file in $(find . -name *.php -print)
do
count=$(wc -l $file)
let total_count+=count
done
echo "$total_count"
Antwoord 11
De tool Tokeigeeft statistieken weer over code in een directory. Tokei toont het aantal bestanden, het totale aantal regels binnen die bestanden en code, opmerkingen en spaties gegroepeerd op taal. Tokei is ook beschikbaar op Mac, Linux en Windows.
Een voorbeeld van de uitvoer van Tokei is als volgt:
$ 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 kan worden geïnstalleerd door de instructies in het README-bestand in de opslagplaats.
Antwoord 12
Alleen voor bronnen:
wc `find`
Gebruik gewoon grep:
om te filteren
wc `find | grep .php$`
Antwoord 13
Een rechttoe rechtaan die snel zal zijn, alle zoek-/filterkracht van findzal gebruiken, niet zal falen als er te veel bestanden zijn (getalargumenten overlopen), goed werken met bestanden met grappige symbolen in hun naam, zonder xargste gebruiken, en zal geen nutteloos groot aantal externe commando’s lanceren (dankzij +voor find‘s -exec). Hier ga je:
find . -name '*.php' -type f -exec cat -- {} + | wc -l
Antwoord 14
Ik weet dat de vraag is getagd als bash, maar het lijkt erop dat het probleem dat u probeert op te lossen ook PHP-gerelateerd is.
Sebastian Bergmann schreef een tool genaamd PHPLOCdie doet wat je wilt en je bovendien een overzicht geeft van de complexiteit. Dit is een voorbeeld van het rapport:
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
Zoals je kunt zien, is de verstrekte informatie veel nuttiger vanuit het perspectief van een ontwikkelaar, omdat het je ongeveer kan vertellen hoe complex een project is voordat je ermee aan de slag gaat.
15
Voor Windows , een eenvoudig en snel hulpmiddel is locmetrics .
16
Als u uw resultaten gesorteerd op het aantal regels, kunt u gewoon | sortof | sort -r(-rvoor aflopende volgorde) naar het eerste antwoord, zoals SO:
find . -name '*.php' | xargs wc -l | sort -r
17
Als u eerst de langste bestanden geeft (dwz misschien hebben deze lange bestanden enkele refactoring liefde nodig?), en exclusief enkele leveranciersdirectory’s:
find . -name '*.php' | xargs wc -l | sort -nr | egrep -v "libs|tmp|tests|vendor" | less
18
heel eenvoudig:
find /path -type f -name "*.php" | while read FILE
do
count=$(wc -l < $FILE)
echo "$FILE has $count lines"
done
19
Iets anders:
wc -l `tree -if --noreport | grep -e'\.php$'`
Dit werkt goed, maar je moet ten minste één *.php-bestand hebben in de huidige map of een van zijn submappen, of anders wckraampjes.
20
Het is heel gemakkelijk met z shell (ZSH) globs:
wc -l ./**/*.php
Als u bash gebruikt, moet u gewoon upgraden. Er is absoluut geen reden om Bash te gebruiken.
21
U kunt een hulpprogramma gebruiken dat codel(Link ) wordt gebruikt. Het is een eenvoudige Python-module om lijnen met kleurrijke opmaak te tellen.
Installatie
pip install codel
Gebruik
Om lijnen van C++ -bestanden te tellen (met .cppen .hExtensions), gebruik:
codel count -e .cpp .h
U kunt ook enkele bestanden / map negeren met de .gitignore-indeling:
codel count -e .py -i tests/**
Het negeert alle bestanden in de tests/Map.
De uitvoer ziet eruit als:
U kunt ook de uitvoer verkorten met de -s-vlag. Het zal de informatie van elk bestand verbergen en alleen informatie over elke extensie weergeven. Het voorbeeld is hieronder:
22
Als u het eenvoudig wilt houden, knip de tussenpersoon uit en bel dan gewoon wcmet alle bestandsnamen:
wc -l `find . -name "*.php"`
of in de moderne syntaxis:
wc -l $(find . -name "*.php")
Dit werkt zolang er geen spaties in een van de mappennamen of bestandsnamen zijn. En zolang je geen tienduizenden bestanden hebt (moderne schelpen ondersteunen echt lange opdrachtregels). Uw project heeft 74 bestanden, dus u hebt voldoende ruimte om te groeien.
23
Als de bestanden te veel zijn, beter om te zoeken naar het aantal totale regel.
find . -name '*.php' | xargs wc -l | grep -i ' total' | awk '{print $1}'
Antwoord 24
Als je alleen het totale aantal regels nodig hebt in, laten we zeggen, je PHP-bestanden, dan kun je een heel eenvoudig commando van één regel gebruiken, zelfs onder Windows als je GnuWin32 hebt geïnstalleerd. Zoals dit:
cat `/gnuwin32/bin/find.exe . -name *.php` | wc -l
U moet specificeren waar de find.exe precies is, anders verstrekt Windows FIND.EXE(van de oude DOS-achtige commando’s) zal worden uitgevoerd, aangezien het waarschijnlijk voor de GnuWin32 in de omgeving PATH is en verschillende parameters en resultaten heeft.
Houd er rekening mee dat u in de bovenstaande opdracht achterste aanhalingstekens moet gebruiken, geen enkele aanhalingstekens.
Antwoord 25
Hoewel ik de scripts leuk vind, geef ik de voorkeur aan deze omdat deze ook een samenvatting per bestand laat zien, zolang het totaal is:
wc -l `find . -name "*.php"`
Antwoord 26
Je hebt al deze ingewikkelde en moeilijk te onthouden commando’s niet nodig. Je hebt alleen een Python-tool nodig met de naam line-counter.
Een snel overzicht
Zo krijg je de tool
$ pip install line-counter
Gebruik de opdracht lineom het aantal bestanden en het aantal regels onder de huidige map te krijgen (recursief):
$ line
Search in /Users/Morgan/Documents/Example/
file count: 4
line count: 839
Als je meer details wilt, gebruik dan gewoon 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
En het beste van deze tool is dat je er een .gitignore-achtig configuratiebestand aan kunt toevoegen. Je kunt regels instellen om te selecteren of te negeren wat voor soort bestanden je moet tellen, net zoals je doet in ‘.gitignore’.
Meer beschrijving en gebruik is hier: https://github.com/MorganZhang100/line-counter