bash study निर्देशिका में कोड की सभी पंक्तियों को दोबारा कैसे गिनें?




इलेक्टोरल पॉलिटिक्स क्लास ९ नोट्स इन हिंदी (24)

हमारे पास एक PHP अनुप्रयोग है और एक विशिष्ट निर्देशिका और इसकी उपनिर्देशिका के तहत कोड की सभी पंक्तियों को गिनना चाहता हूं। हमें टिप्पणियों को अनदेखा करने की आवश्यकता नहीं है, क्योंकि हम सिर्फ एक मोटा विचार पाने की कोशिश कर रहे हैं।

wc -l *.php 

वह आदेश किसी दिए गए निर्देशिका में बहुत अच्छा काम करता है, लेकिन उपनिर्देशिका को अनदेखा करता है। मैं सोच रहा था कि यह काम कर सकता है, लेकिन यह 74 लौट रहा है, जो निश्चित रूप से मामला नहीं है ...

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

सभी फाइलों में फ़ीड करने के लिए सही वाक्यविन्यास क्या है?


कुछ अलग:

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

यह ठीक काम करता है, लेकिन आपको वर्तमान फ़ोल्डर में कम से कम एक *.php फ़ाइल या इसके सबफ़ोल्डर में से एक होना चाहिए, या फिर wc stalls


बहुत सरल

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

एक और लाइनर के लिए:

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

रिक्त स्थान वाले नामों पर काम करता है, केवल एक नंबर आउटपुट करता है।


यदि आपको केवल अपनी PHP फाइलें कहने के लिए लाइनों की कुल संख्या की आवश्यकता है तो आप Windows के तहत भी बहुत सरल एक लाइन कमांड का उपयोग कर सकते हैं यदि आपके पास GnuWin32 इंस्टॉल है। इस कदर:

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

आपको यह निर्दिष्ट करने की आवश्यकता है कि find.exe कहां है, अन्यथा विंडोज़ FIND.EXE प्रदान करता है (पुराने डॉस-जैसी कमांड से) निष्पादित किया जाएगा, क्योंकि यह संभवतः पर्यावरण PATH में GnuWin32 से पहले है, और इसमें विभिन्न पैरामीटर और परिणाम हैं।

कृपया ध्यान दें कि उपरोक्त आदेश में आपको बैक-कोट्स का उपयोग करना चाहिए, एकल उद्धरण नहीं।


फिर भी एक और बदलाव :)

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

संपादित करें: यह फ़ाइल-दर-फ़ाइल के बजाय कुल योग देगा।


मुझे पता है कि सवाल को bash रूप में टैग किया गया है, लेकिन ऐसा लगता है कि जिस समस्या को आप हल करने का प्रयास कर रहे हैं वह भी PHP से संबंधित है।

सेबेस्टियन PHPLOC ने 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

जैसा कि आप देख सकते हैं, प्रदान की गई जानकारी डेवलपर के परिप्रेक्ष्य से बहुत अधिक उपयोगी है, क्योंकि यह मोटे तौर पर आपको बता सकती है कि इससे पहले कि आप इसके साथ काम करना शुरू कर सकें, एक परियोजना कितनी जटिल है।


यदि आप अपने परिणामों को लाइनों की संख्या से क्रमबद्ध करना चाहते हैं, तो आप बस जोड़ सकते हैं | sort या | sort -r | sort -r (अवरोही क्रम के लिए -r ) पहले जवाब में, जैसे:

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

आप जो चाहते हैं वह लूप के लिए आसान है:

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

मेरे विंडोज सिस्टम पर व्यस्त बॉक्स स्थापित है। तो मैंने यह किया।

ECHO OFF
for /r %%G in (*.php) do (
busybox grep . "%%G" | busybox wc -l
) 

यदि बैश (या जेडएसएच) के एक निश्चित हाल के संस्करण का उपयोग करते हुए, यह बहुत आसान है:

wc -l **/*.php

बैश खोल में इसे globstar विकल्प सेट करने की आवश्यकता होती है, अन्यथा ** ग्लोब-ऑपरेटर रिकर्सिव नहीं है। इस सेटिंग को सक्षम करने के लिए, जारी करें

shopt -s globstar

इसे स्थायी बनाने के लिए, इसे प्रारंभिक फ़ाइलों में से एक ( ~/.bashrc , ~/.bash_profile इत्यादि) में जोड़ें।


केवल स्रोतों के लिए:

wc `find`

फिल्टर करने के लिए, बस grep का उपयोग करें

wc `find | grep .php$`


$cd directory
$wc -l* | sort -nr

डब्ल्यूसी-एल? बेहतर जीआरईपी-सी ^ का उपयोग करें

wc -l? गलत! डब्ल्यूसी कमांड नई लाइन कोड की गणना करता है, लाइनों नहीं ! जब फ़ाइल में अंतिम पंक्ति नए लाइन कोड के साथ समाप्त नहीं होती है, तो यह गिना नहीं जाएगा!

यदि आप अभी भी गिनती लाइन चाहते हैं, तो 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 ./ -type f -exec wc -l {}  \; | cut -d' ' -f1 | paste -sd+ | bc

अन्य उत्तरों से मुख्य अंतर:

  1. find -exec का उपयोग कर,
  2. पेस्ट (कट के साथ) का उपयोग कर,
  3. बीसी का उपयोग कर

आप cloc.sourceforge.net उपयोगिता का उपयोग कर सकते हैं जो इस सटीक उद्देश्य के लिए बनाया गया है। यह प्रत्येक भाषा में प्रत्येक पंक्ति की प्रत्येक पंक्ति की रिपोर्ट करता है, साथ में उनमें से कितने टिप्पणियां आदि हैं।

उपयोग और आउटपुट उदाहरण:

$ 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.sourceforge.net भी कोशिश कर सकते हैं (पर्ल की आवश्यकता है)


मैंने इस इनलाइन-स्क्रिप्ट का उपयोग किया जो मैं src-project की निर्देशिका से लॉन्च करता हूं:

 for i in $(find . -type f); do rowline=$(wc -l $i | cut -f1 -d" "); file=$(wc -l $i | cut -f2 -d" "); lines=$((lines + rowline)); echo "Lines["$lines"] " $file "has "$rowline"rows."; done && unset lines

यह इस आउटपुट का उत्पादन करता है:

Lines[75]  ./Db.h has 75rows.
Lines[143]  ./Db.cpp has 68rows.
Lines[170]  ./main.cpp has 27rows.
Lines[294]  ./Sqlite.cpp has 124rows.
Lines[349]  ./Sqlite.h has 55rows.
Lines[445]  ./Table.cpp has 96rows.
Lines[480]  ./DbError.cpp has 35rows.
Lines[521]  ./DbError.h has 41rows.
Lines[627]  ./QueryResult.cpp has 106rows.
Lines[717]  ./QueryResult.h has 90rows.
Lines[828]  ./Table.h has 111rows.

प्रयत्न:

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

एसएलओसीसीउंट टूल भी मदद कर सकता है।

यह कोड पदान की सटीक स्रोत रेखाएं जो भी पदानुक्रम आप इंगित करते हैं, साथ ही साथ कुछ अतिरिक्त आंकड़े भी देंगे।


एक सीधा जो तेजी से होगा, खोज की सभी खोज / फ़िल्टरिंग शक्ति का उपयोग करेगा, बहुत अधिक फाइलें (संख्या तर्क ओवरफ्लो) होने पर असफल नहीं होते हैं, xargs का उपयोग किये बिना, उनके नाम पर मजाकिया प्रतीकों वाली फ़ाइलों के साथ ठीक काम करते हैं, नहीं बाहरी आदेशों की बेकार उच्च संख्या लॉन्च करें ( find लिए + find लिए धन्यवाद)। हेयर यू गो:

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

कम से कम ओएस एक्स पर, कुछ अन्य उत्तरों में सूचीबद्ध + xarg + wc कमांड बड़े लिस्टिंग पर कई बार "कुल" प्रिंट करता है, और कोई पूर्ण कुल दिया गया नहीं है। मैं निम्नलिखित कमांड का उपयोग कर .c फ़ाइलों के लिए एक एकल प्राप्त करने में सक्षम था:

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


यूनिक्स जैसी प्रणालियों पर, 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




shell