Bir dizindeki tüm kod satırlarını özyinelemeli olarak nasıl sayabilirim?

Bir PHP uygulamamız var ve belirli bir dizin ve alt dizinleri altındaki tüm kod satırlarını saymak istiyoruz. Sadece kaba bir fikir edinmeye çalıştığımız için yorumları görmezden gelmemize gerek yok.

wc -l *.php 

Bu komut belirli bir dizinde harika çalışıyor ancak alt dizinleri yok sayar. Bunun işe yarayabileceğini düşünüyordum, ama 74 geri dönüyor, ki bu kesinlikle böyle değil ...

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

Tüm dosyaları beslemek için doğru sözdizimi nedir?

Deneyin:

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

SLOCCount aracı da yardımcı olabilir.

İşaret ettiğiniz hiyerarşi için doğru kaynak kod satırlarının yanı sıra bazı ek istatistikler de verecektir.

Sıralama çıktı:

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

Başka bir astar için:

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

boşluklu isimler üzerinde çalışır, yalnızca bir sayı verir.

Bash'in (veya ZSH) son derece uygun bir sürümünü kullanıyorsanız, çok daha basittir:

wc -l **/*.php

Bash kabuğunda bu, globstarseçeneğin ayarlanmasını gerektirir , aksi takdirde **glob operatörü özyinelemez. Bu ayarı etkinleştirmek için sorun

shopt -s globstar

Bu kalıcı yapmak için, başlatma dosyalarından birinde (eklemek ~/.bashrc, ~/.bash_profilevs.).

Kullanabilirsiniz clocBu amaç için oluşturulmuş yardımcı programı . Her dilde satır sayısını, bunların kaç tanesi yorum vb. İle birlikte rapor eder. CLOC, Linux, Mac ve Windows'ta kullanılabilir.

Kullanım ve çıktı örneği:

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

UNIX benzeri sistemlerde, clockod istatistikleri sağlayan bir araç vardır .

Kod tabanımızda rastgele bir dizinde koştum diyor:

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

Kaç dosya olduğunu veya istenen çıktıyı belirtmediniz. Aradığınız bu mu:

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

Yine başka bir varyasyon :)

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

Düzenle: dosyaya göre toplamı verir.

Edit2: Ekleme .sonra findbu işi yapmak için

Şaşırtıcı bir şekilde find's -execve awk. İşte başlıyoruz:

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

Bu snippet tüm dosyaları ( -type f) bulur . Dosya uzantısına göre bulmak için şunu kullanın -name:

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

Benim için daha yaygın ve basit, farklı ad uzantılarına sahip dosyaları saymanız gerektiğini varsayalım (aynı zamanda yerliler de)

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

Geri bildiriminiz için teşekkür ederim, düzelttim.

POSIX

Buradaki diğer yanıtların çoğundan farklı olarak, bunlar herhangi bir POSIX sisteminde, herhangi bir sayıda dosyada ve herhangi bir dosya adıyla (not edilenler hariç) çalışır.

Her dosyadaki satırlar:

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

Her dosyadaki dosya yoluna göre sıralanmış satırlar

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

Her dosyadaki satırlar, satır sayısına göre sıralanmış, azalan

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

Tüm dosyalardaki toplam satırlar

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

Dizindeki kod satırlarını saymak için sloccount adında küçük bir araç var . Boş satırları / yorumları göz ardı ettiği, programlama dili başına sonuçları grupladığı ve bazı istatistikleri hesapladığı için, istediğinizden daha fazlasını yaptığı unutulmamalıdır.

İstediğiniz basit bir fordöngüdür:

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

yalnızca kaynaklar için:

wc `find`

filtrelemek için sadece grep kullanın

wc `find | grep .php$`

Hızlı olacak basit olan, tüm arama / filtreleme gücünü kullanacak find, çok fazla dosya (sayı bağımsız değişkenleri taşması) olduğunda başarısız olmayacak, adlarında komik sembollere sahip dosyalarla iyi çalışacak, kullanmadan xargsbir dış komutları boş yere çok sayıda (sayesinde +için findVar -exec). Hadi bakalım:

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

Sorunun şu şekilde etiketlendiğini biliyorum darbe, ancak çözmeye çalıştığınız sorunun PHP ile ilgili olduğu anlaşılıyor.

Sebastian Bergmann, PHPLOC adlı bir araç yazdı ve istediğini yaptı ve bunun üzerine sana bir projenin karmaşıklığına genel bir bakış sağladı . Bu raporuna bir örnektir:

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

Gördüğünüz gibi, sağlanan bilgiler bir geliştiricinin bakış açısından çok daha yararlıdır, çünkü bir projeyle çalışmaya başlamadan önce kabaca ne kadar karmaşık olduğunu söyleyebilir.

Kimsenin bunu arkada gömülü görmeyeceğini tahmin etmek ... Şimdiye kadar cevapların hiçbiri boşluklu dosya isimleri sorununa girmiyor. Ayrıca, xargsağaçtaki toplam yol uzunluğu kabuk ortamı boyut sınırını aşarsa (Linux'ta varsayılan olarak birkaç megabayta karşılık gelir) , kullanılanların tümü başarısız olur. İşte bu sorunları oldukça doğrudan çözen bir problem. Alt kabuk, boşluklu dosyalarla ilgilenir. Tek awktek dosya wcçıktılarının akışını toplar, bu yüzden asla boş alan kalmamalıdır. Ayrıca execyalnızca dosyalarla da kısıtlanır (dizinleri atlamak):

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

WC -L? daha iyi kullanmak GREP -C ^

wc -l? Yanlış! wc komutu satırları değil , yeni satır kodlarını sayar ! Dosyadaki son satır yeni satır koduyla bitmediğinde, bu sayılmaz!

hala sayı çizgileri istiyorsanız grep -c ^ kullanın , tam örnek:

#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

Son olarak, wc -l tuzağına dikkat edin (sayım girer, satır değil !!!)

Zsh globs ile çok kolay:

wc -l ./**/*.php

Eğer bash kullanıyorsanız, yükseltmeniz yeterlidir. Bash kullanmak için kesinlikle hiçbir sebep yoktur.

çok basit

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

Sonuçlarınızın satır sayısına göre sıralanmasını istiyorsanız , ilk yanıta yalnızca | sortveya | sort -r( -razalan düzen için) ekleyebilirsiniz , örneğin:

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

İçin , Windows , kolay ve hızlı bir araçtır LocMetrics .

Farklı birşey:

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

Bu iyi çalışıyor, ancak *.phpgeçerli klasörde veya alt klasörlerinden birinde veya başka wctezgahlarda en az bir dosya olması gerekiyor

Linux'taysanız (ve bunu siz alıyorum), araç çokgenliğimi tavsiye ederim . Daha hızlı daha dramatik ya sloccountya clocve daha özellikli olduğunu sloccount.

İle çağırabilirsiniz

poly .

veya

poly

bu yüzden bazı kıvrımlı bash betiğinden çok daha kullanıcı dostu.

Tokei aracı bir dizindeki kodla ilgili istatistikleri görüntüler. Tokei dosya sayısını, bu dosyalar içindeki toplam satırları ve dile göre gruplandırılmış kodları, yorumları ve boşlukları gösterir. Tokei ayrıca Mac, Linux ve Windows'ta da mevcuttur.

Tokei'nin çıktısının bir örneği aşağıdaki gibidir:

$ 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 , depodaki README dosyasındaki yönergeleri izleyerek yüklenebilir .

Sadece toplam satır sayısına ihtiyacınız varsa, PHP dosyalarınızın Windows altında bile çok basit bir satır komutu kullanabileceğinizi varsayalım. Bunun gibi:

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

Tam olarak find.exe'nin nerede olduğunu belirtmeniz gerekir, aksi takdirde Windows sağlanan FIND.EXE (eski DOS benzeri komutlardan), muhtemelen PATH ortamında GnuWin32'den önce olduğundan ve farklı parametreler ve sonuçlar içerdiğinden yürütülecektir.

Yukarıdaki komutta tek tırnak değil, geri tırnak kullanmanız gerektiğini lütfen unutmayın.

Önce en uzun dosyaları vermek (örneğin, bu uzun dosyaların yeniden düzenleme sevgisine ihtiyacı vardır?) Ve bazı satıcı dizinlerini hariç tutmak:

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

Basit tutmak istiyorsanız, aracıyı kesin ve wctüm dosya adlarını arayın :

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

Veya modern sözdiziminde:

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

Dizin adlarının veya dosya adlarının hiçbirinde boşluk olmadığı sürece çalışır. Ve on binlerce dosyanız olmadığı sürece (modern kabuklar gerçekten uzun komut satırlarını destekler). Projenizde 74 dosya var, bu yüzden büyümek için bolca yeriniz var.

Tüm bu karmaşık ve hatırlanması zor komutlara ihtiyacınız yok. Sadece line-counter adlı bir araca ihtiyacınız var .

Hızlı bir genel bakış

Aracı bu şekilde elde edersiniz

$ pip install line-counter

lineGeçerli dizin altında dosya sayısını ve satır sayısını almak için komutu kullanın (yinelemeli olarak)

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

Daha fazla ayrıntı istiyorsanız, sadece kullanın 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

Ve bu aracın en iyi yanı, buna .gitignoreyapılandırma dosyası ekleyebilirsiniz . '.Gitignore' öğesinde yaptığınız gibi ne tür dosyaların sayılacağını seçmek veya yoksaymak için kurallar ayarlayabilirsiniz.

Daha fazla açıklama ve kullanım burada: https://github.com/MorganZhang100/line-counter

Dosyalar çok fazla ise, toplam satır sayısını aramak daha iyidir.

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

En az OS X'te, diğer cevapların bazılarında listelenen find + xarg + wc komutları büyük listelerde birkaç kez "toplam" yazdırır ve verilen toplamın tamamı yoktur. Aşağıdaki komutu kullanarak .c dosyaları için tek bir toplam elde edebildim:

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