නාමාවලියක ඇති සියලුම කේත රේඛා පුනරාවර්තනය ලෙස ගණනය කරන්නේ කෙසේද?

අපට PHP යෙදුමක් ඇති අතර නිශ්චිත නාමාවලියක් සහ එහි උප බහලුම් යටතේ කේත පේළි සියල්ල ගණනය කිරීමට අවශ්‍යය. අප දළ අදහසක් ලබා ගැනීමට උත්සාහ කරන බැවින් අදහස් නොසලකා හැරීමට අපට අවශ්‍ය නැත.

wc -l *.php 

දී ඇති නාමාවලියක් තුළ එම විධානය විශිෂ්ට ලෙස ක්‍රියා කරයි, නමුත් උප බහලුම් නොසලකා හරියි. මම හිතුවේ මේක වැඩ කරයි කියලා, නමුත් එය නැවත 74 ක් එනවා, එය අනිවාර්යයෙන්ම එසේ නොවේ ...

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

සියලුම ලිපිගොනු වල පෝෂණය කිරීම සඳහා නිවැරදි වාක්‍ය ඛණ්ඩය කුමක්ද?

උත්සාහ කරන්න:

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

SLOCCount මෙවලම ද උදව් විය හැකිය.

එය ඔබ යොමු කරන ඕනෑම ධූරාවලියක් සඳහා කේත සංඛ්‍යා වල නිවැරදි ප්‍රභව රේඛා මෙන්ම අමතර සංඛ්‍යාලේඛන ලබා දෙනු ඇත.

වර්ග කළ ප්‍රතිදානය:

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

තවත් එක් ලයිනර් සඳහා:

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

අවකාශයන් සහිත නම් මත ක්‍රියා කරයි, ප්‍රතිදානය කරන්නේ එක් අංකයක් පමණි.

මෑතදී බාෂ් (හෝ ZSH) හි අනුවාදයක් භාවිතා කරන්නේ නම්, එය වඩාත් සරල ය:

wc -l **/*.php

බෑෂ් කවචයේ මේ සඳහා globstarවිකල්පය සැකසීමට අවශ්‍ය වේ , එසේ **නොමැතිනම් ග්ලෝබ්-ක්‍රියාකරු පුනරාවර්තන නොවේ. මෙම සිටුවම සක්‍රිය කිරීමට, නිකුත් කරන්න

shopt -s globstar

මෙම ස්ථිර කිරීම, (ආරම්භය ගොනු එක් වෙත එක් ~/.bashrc, ~/.bash_profileආදිය).

ඔබට භාවිතා කළ හැකිය clocමෙම නිශ්චිත අරමුණ සඳහා ගොඩනගා උපයෝගීතාව . එය එක් එක් භාෂාවේ පේළි ප්‍රමාණය සහ ඒවායින් කීයක් අදහස් දැක්වීම් ආදිය වාර්තා කරයි. CLOC ලිනක්ස්, මැක් සහ වින්ඩෝස් වලින් ලබා ගත හැකිය.

භාවිතය සහ ප්‍රතිදාන උදාහරණය:

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

යුනික්ස් වැනි පද්ධති වල, clocකේත සංඛ්‍යාලේඛන සපයන මෙවලමක් ඇත.

මම අපේ කේත පදනමේ අහඹු නාමාවලියක් වෙත දිව ගියෙමි:

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

ලිපිගොනු කීයක් තිබේද යන්න හෝ අපේක්ෂිත ප්‍රතිදානය කුමක්දැයි ඔබ සඳහන් කර නැත. ඔබ සොයන්නේ මෙයද:

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

තවත් විචලනය :)

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

සංස්කරණය කරන්න: මෙය ගොනුව-ගොනුව වෙනුවට මුළු මුදල ලබා දෙනු ඇත.

Edit2: එය ක්‍රියාත්මක කිරීමට .පසුව එකතු කරන්නfind

පුදුමයට කරුණක් නම් සොයාගැනීම් -execසහ පදනම් කරගත් පිළිතුරක් නොමැත awk. මෙන්න අපි යනවා:

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

මෙම ස්නිපටය සියලුම ගොනු ( -type f) සඳහා සොයා ගනී . ගොනු දිගුව මගින් සොයා ගැනීමට, භාවිතා කරන්න -name:

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

මට වඩා පොදු හා සරල නම්, ඔබට විවිධ නම් දිගු වල ගොනු ගණන් කිරීමට අවශ්‍ය යැයි සිතමු (කියන්න, ස්වදේශිකයන් ද)

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

ප්‍රතිපෝෂණයට ස්තූතියි, මම එය නිවැරදි කර ඇත්තෙමි.

පොසික්ස්

මෙහි ඇති වෙනත් බොහෝ පිළිතුරු මෙන් නොව, මේවා ඕනෑම POSIX පද්ධතියක, ඕනෑම ගොනු ගණනක් සඳහා සහ ඕනෑම ගොනු නාමයක් සමඟ (සටහන් කර ඇති ස්ථාන හැර) ක්‍රියා කරයි.

එක් එක් ගොනුවේ රේඛා:

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

එක් එක් ගොනුවේ රේඛා, ගොනු මාර්ගය අනුව වර්ග කර ඇත

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

එක් එක් ගොනුවේ රේඛා, පේළි ගණන අනුව වර්ග කර, බැස යයි

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

සියලුම ලිපිගොනු වල මුළු පේළි

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

නාමාවලියෙහි කේත රේඛා ගණනය කිරීම සඳහා sloccount නමින් කුඩා මෙවලමක් තිබේ. එය හිස් රේඛා / අදහස් නොසලකා හැරීම, ක්‍රමලේඛන භාෂාවකට ප්‍රති results ල කාණ්ඩගත කිරීම සහ සමහර සංඛ්‍යාලේඛන ගණනය කිරීම නිසා එය ඔබට අවශ්‍ය ප්‍රමාණයට වඩා වැඩි යමක් කරන බව සැලකිල්ලට ගත යුතුය.

ඔබට අවශ්‍ය වන්නේ සරල forපුඩුවක්:

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

ප්‍රභවයන් සඳහා පමණි:

wc `find`

පෙරීමට, grep භාවිතා කරන්න

wc `find | grep .php$`

වේගවත් එකක් වනු ඇත, සියලු සෙවුම් / පෙරීමේ බලය භාවිතා කරනු ඇත, findබොහෝ ලිපිගොනු ඇති විට අසමත් නොවනු ඇත (සංඛ්‍යා තර්ක පිටාර ගැලීම), ඒවායේ නමින් විහිලු සංකේත සහිත ලිපිගොනු සමඟ හොඳින් වැඩ කරන්න, භාවිතා නොකර xargs, දියත් නොකරනු ඇත බාහිර විධාන (ස්තූති වැඳුම් පිඳුම් ඉහළ අංකය +සඳහා findගේ -exec). හියර් යූ ගෝ:

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

කිසිවෙකු මෙය පිටුපස වළලා ඇති බවක් නොපෙනේ යැයි අනුමාන කරයි ... එහෙත් මේ දක්වා කිසිදු පිළිතුරක් අවකාශයන් සහිත ගොනු නාම පිළිබඳ ගැටලුවට නොගැලපේ. මීට අමතරව, xargsගසෙහි සම්පූර්ණ මාර්ගවල දිග ෂෙල් පරිසර ප්‍රමාණයේ සීමාව ඉක්මවා ගියහොත් (ලිනක්ස් හි මෙගාබයිට් කිහිපයකට පෙරනිමිය) භාවිතා කරන සියල්ල අසාර්ථක වේ. මෙන්න මෙම ගැටළු ඉතා සෘජු ආකාරයකින් විසඳන එකක්. උපසිරැසිය අවකාශය සහිත ලිපිගොනු බලා ගනී. මෙම awkඑක් එක් ගොනුව ඇළ දෙනෙක් ඉන්නවා wcනිමැවුම්, එසේ ඉඩකඩ මදි වීමක් සිදු නොකල යුතුව. එය execලිපිගොනු වලට පමණක් සීමා කරයි (නාමාවලි මඟ හැරීම):

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

ප්‍රශ්නය ටැග් කර ඇති බව මම දනිමි bash, නමුත් ඔබ විසඳීමට උත්සාහ කරන ගැටළුව PHP හා සම්බන්ධ බව පෙනේ.

සෙබස්තියන් බර්ග්මන් විසින් ඔබට අවශ්‍ය දේ කරන PHPLOC නමින් මෙවලමක් ලියා ඇති අතර ඒ මත ඔබට ව්‍යාපෘතියක සංකීර්ණතාව පිළිබඳ දළ විශ්ලේෂණයක් ලබා දේ. මෙය එහි වාර්තාවට උදාහරණයකි:

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

ඔබට පෙනෙන පරිදි, ලබා දී ඇති තොරතුරු සංවර්ධකයෙකුගේ දෘෂ්ටිකෝණයෙන් වඩා බෙහෙවින් ප්‍රයෝජනවත් වේ, මන්දයත් ඔබ එය සමඟ වැඩ කිරීමට පෙර ව්‍යාපෘතියක් කෙතරම් සංකීර්ණද යන්න දළ වශයෙන් ඔබට පැවසිය හැකිය.

WC -L? වඩා හොඳ GREP -C use භාවිතා කරන්න

wc -l? වැරදි! wc විධානය නව රේඛා කේත ගණන් කරයි, මිස රේඛා නොවේ ! ගොනුවේ අවසාන පේළිය නව රේඛා කේතයකින් අවසන් නොවන විට, මෙය ගණන් නොගනු ඇත!

ඔබට තවමත් ගණන් රේඛා අවශ්‍ය නම් භාවිතා කරන්න 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

අවසාන වශයෙන්, wc -l උගුල ගැන විමසිල්ලෙන් සිටින්න (ගණන් ඇතුල් වන්නේ රේඛා නොව !!!)

ඉතා සරලව

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

ඔබේ ප්‍රති results ල පේළි ගණන අනුව වර්ග කිරීමට ඔබට අවශ්‍ය නම්, ඔබට පළමු පිළිතුරට එකතු කළ හැකිය ( | sortහෝ බැසීමේ අනුපිළිවෙල සඳහා), එසේ ය:| sort -r-r

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

සඳහා Windows , පහසු සහ ඉක්මන් මෙවලමකි LocMetrics .

වෙනස් දෙයක්:

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

මෙය හොඳින් ක්‍රියාත්මක වේ, නමුත් ඔබට *.phpදැනට පවතින ෆෝල්ඩරයේ අවම වශයෙන් එක් ගොනුවක් හෝ එහි උප ෆෝල්ඩරයක් තිබිය යුතුය, නැතිනම් wcකුටි

ඔබ ලිනක්ස් හි සිටී නම් (මම එය ඔබම ගන්නෙමි), මම නිර්දේශ කරන්නේ මගේ මෙවලම පොලිග්ලොට් ය . එය නාටකාකාර ලෙස වඩා වේගයෙන් එක්කෝ sloccountහෝ clocඑය වඩා featureful වේ sloccount.

ඔබට එය කැඳවිය හැකිය

poly .

හෝ

poly

එබැවින් එය සමහර කැටි ගැසුණු බාෂ් ස්ක්‍රිප්ටයට වඩා පරිශීලක-හිතකාමී ය.

Zsh ග්ලෝබ් සමඟ එය ඉතා පහසු ය:

wc -l ./**/*.php

ඔබ bash භාවිතා කරන්නේ නම්, ඔබට යාවත්කාලීන කළ යුතුය. බාෂ් භාවිතා කිරීමට කිසිම හේතුවක් නැත.

ටෝකී මෙවලම නාමාවලියක කේතය පිළිබඳ සංඛ්‍යාලේඛන පෙන්වයි. ටෝකී විසින් ලිපිගොනු ගණන, එම ලිපිගොනු තුළ ඇති සම්පූර්ණ රේඛා සහ කේතය, අදහස් සහ භාෂාව අනුව කාණ්ඩ කර ඇති හිස් තැන් පෙන්වනු ඇත. ටෝකී මැක්, ලිනක්ස් සහ වින්ඩෝස් වලද ඇත.

ටෝකෙයිහි ප්‍රතිදානය පිළිබඳ උදාහරණයක් පහත පරිදි වේ:

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

ගබඩාවේ ඇති README ගොනුවේ ඇති උපදෙස් අනුගමනය කිරීමෙන් ටෝකී ස්ථාපනය කළ හැකිය .

ඔබට සම්පූර්ණ පේළි ගණන අවශ්‍ය නම් ඔබගේ PHP ලිපිගොනු කියමු ඔබ GnuWin32 ස්ථාපනය කර ඇත්නම් වින්ඩෝස් යටතේ වුවද ඉතා සරල එක් පේළියේ විධානයක් භාවිතා කළ හැකිය. මෙවැනි:

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

Find.exe හරියටම කොහේදැයි ඔබ විසින් නියම කළ යුතුය. එසේ නොවුවහොත් වින්ඩෝස් විසින් සපයන ලද FIND.EXE (පැරණි ඩොස් වැනි විධානයන්ගෙන්) ක්‍රියාත්මක වනු ඇත, මන්ද එය බොහෝ විට PATH පරිසරයේ GnuWin32 ට පෙර විය හැකි අතර විවිධ පරාමිතීන් හා ප්‍රති .ල ඇත.

ඉහත විධානයෙහි ඔබ භාවිතා කළ යුත්තේ තනි උපුටා දැක්වීම් නොව පසු-උපුටා දැක්වීම් බව කරුණාවෙන් සලකන්න.

පළමුවෙන්ම දීර් long තම ලිපිගොනු ලබා දීම (එනම්, සමහර විට මෙම දිගු ලිපිගොනු වලට ප්‍රතිනිර්මාණය කිරීමේ ආදරය අවශ්‍යද?), සහ සමහර විකුණුම් නාමාවලි හැර:

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

ඔබට එය සරළව තබා ගැනීමට අවශ්‍ය නම්, අතරමැදියා කපා wcසියලු ගොනු නාමයන් සමඟ අමතන්න :

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

හෝ නූතන වාක්‍ය ඛණ්ඩයේ:

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

කිසිදු නාමාවලි නාමයක හෝ ගොනු නාමයක ඉඩක් නොමැති තාක් කල් ක්‍රියා කරයි. ඔබට ලිපිගොනු දස දහස් ගණනක් නොමැති තාක් කල් (නවීන කවච සැබවින්ම දිගු විධාන රේඛාවලට සහය දක්වයි). ඔබේ ව්‍යාපෘතියේ ලිපිගොනු 74 ක් ඇත, එබැවින් ඔබට වර්ධනය වීමට ඕනෑ තරම් ඉඩ තිබේ.

විධාන මතක තබා ගැනීමට ඔබට මේ සියල්ල සංකීර්ණ හා දුෂ්කර නොවේ. ඔබට අවශ්‍ය වන්නේ රේඛීය කවුන්ටරය නම් මෙවලමක් පමණි .

ඉක්මන් දළ විශ්ලේෂණයක්

ඔබට මෙවලම ලැබෙන ආකාරය මෙයයි

$ pip install line-counter

lineවත්මන් නාමාවලිය යටතේ ගොනු ගණන සහ රේඛා ගණන ලබා ගැනීමට විධානය භාවිතා කරන්න (පුනරාවර්තන ලෙස)

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

ඔබට වැඩි විස්තර අවශ්‍ය නම් භාවිතා කරන්න 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

මෙම මෙවලමෙහි හොඳම කොටස නම්, ඔබට .gitignoreඑයට ගොනුව වින්‍යාස කිරීම වැනි එකතු කළ හැකිය . '.Gitignore' හි ඔබ කරන දේ මෙන් ගණනය කළ යුතු ලිපිගොනු තෝරා ගැනීමට හෝ නොසලකා හැරීමට ඔබට නීති සැකසිය හැකිය.

වැඩි විස්තර සහ භාවිතය මෙහි ඇත: https://github.com/MorganZhang100/line-counter

ලිපිගොනු ඕනෑවට වඩා නම්, මුළු පේළි ගණන සොයා බැලීම වඩා හොඳය.

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

ඔබට codel( සබැඳිය ) නම් උපයෝගීතාවයක් භාවිතා කළ හැකිය . වර්ණවත් හැඩතල ගැන්වීම් සහිත රේඛා ගණනය කිරීම සඳහා සරල පයිතන් මොඩියුලයකි.

ස්ථාපනය

pip install codel

භාවිතය

C ++ ලිපිගොනු රේඛා ගණනය කිරීම සඳහා ( .cppසහ .hදිගු සමඟ ) භාවිතා කරන්න:

codel count -e .cpp .h

.Gitignore ආකෘතියෙන් ඔබට සමහර ගොනු / ෆෝල්ඩරය නොසලකා හැරිය හැකිය:

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

එය tests/ෆෝල්ඩරයේ ඇති සියලුම ගොනු නොසලකා හරිනු ඇත .

ප්‍රතිදානය පෙනේ:

ඔබට -sධජය සමඟ ප්‍රතිදානය කෙටි කළ හැකිය . එය එක් එක් ගොනුවේ තොරතුරු සඟවන අතර එක් එක් දිගුව පිළිබඳ තොරතුරු පමණක් පෙන්වයි. උදාහරණය පහතින්: