bash - source - shell script




Come contare in modo ricorsivo tutte le righe di codice in una directory? (20)

WC -L? meglio usare GREP -C ^

wc -l? Sbagliato! comando wc conta i nuovi codici di linea, non le linee! Quando l'ultima riga nel file non termina con il nuovo codice di linea, questo non verrà conteggiato!

se vuoi ancora contare le linee, usa grep -c ^ , esempio completo:

#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

infine, fai attenzione alla trappola wc -l (i conteggi entrano, non le linee !!!)

Abbiamo un'applicazione PHP e vogliamo contare tutte le linee di codice sotto una directory specifica e le sue sottodirectory. Non abbiamo bisogno di ignorare i commenti, stiamo solo cercando di dare un'idea approssimativa.

wc -l *.php 

Questo comando funziona alla grande all'interno di una determinata directory, ma ignora le sottodirectory. Stavo pensando che questo potrebbe funzionare, ma sta ritornando 74, il che non è assolutamente il caso ...

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

Qual è la sintassi corretta per alimentare tutti i file?


È possibile utilizzare l'utility cloc che è stata costruita per questo scopo esatto. Segnala ciascuna la quantità di righe in ciascuna lingua, insieme a quante di esse sono commenti ecc. CLOC è disponibile su Linux, Mac e Windows.

Esempio di utilizzo e output:

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

Ancora un'altra variazione :)

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

Modifica: questo darà la somma totale, invece di file per file.


C'è un piccolo strumento chiamato sloccount per contare le righe di codice nella directory. Va notato che fa più di quello che vuoi dato che ignora le righe / i commenti vuoti, raggruppa i risultati per linguaggio di programmazione e calcola alcune statistiche.


Esclusa la riga vuota

find . -name "*.php" | xargs grep -v -c '^$' | awk 'BEGIN {FS=":"} { $cnt = $cnt + $2} END {print $cnt}'

Comprese le righe vuote:

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

Ho usato questo inline-script che avvio dalla directory di 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

Questo produce questa uscita:

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.

Non hai bisogno di tutti questi comandi complicati e difficili da ricordare. Hai solo bisogno di uno strumento chiamato contatore di riga .

Una rapida panoramica

Questo è il modo in cui ottieni lo strumento

$ pip install line-counter

Utilizzare il comando line per ottenere il conteggio dei file e il conteggio delle righe nella directory corrente (in modo ricorsivo)

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

Se vuoi maggiori dettagli, usa la 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

E la parte migliore di questo strumento è, è possibile aggiungere .gitignore come configurare il file ad esso. Puoi impostare le regole per selezionare o ignorare il tipo di file da contare, proprio come succede in ".gitignore".

Più descrizione e utilizzo sono qui: https://github.com/MorganZhang100/line-counter


Non hai specificato quanti file ci sono o qual è l'output desiderato. E 'questo quello che stai cercando:

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

Per un'altra nave singola:

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

lavora su nomi con spazi, emette solo un numero.


Più comune e semplice per me, supponiamo di dover contare file di estensioni di nomi diverse (ad esempio, anche nativi)

wc `find . -name '*.[h|c|cpp|php|cc]'`

Qualcosa di diverso:

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

Funziona bene, ma è necessario avere almeno un file *.php nella cartella corrente o in una delle sue sottocartelle, o altro.


Quello che vuoi è un semplice ciclo for :

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

Se sei su Linux (e io lo prendo), ti consiglio il mio strumento polyglot . È notevolmente più veloce rispetto allo sloccount o al cloc ed è più sloccount di sloccount rispetto allo sloccount .

Puoi invocarlo con

poly .

o

poly

quindi è molto più user-friendly di qualche script bash contorto.


Se si utilizza una versione decentemente recente di Bash (o ZSH), è molto più semplice:

wc -l **/*.php

Nella shell Bash è necessario globstar opzione globstar , altrimenti il ** glob-operator non è ricorsivo. Per abilitare questa impostazione, problema

shopt -s globstar

Per renderlo permanente, aggiungilo a uno dei file di inizializzazione ( ~/.bashrc , ~/.bash_profile ecc.).


Se vuoi mantenerlo semplice, ritaglia l'intermediario e chiama wc con tutti i nomi dei file:

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

O nella sintassi moderna:

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

Funziona finché non ci sono spazi in nessuno dei nomi di directory o nomi di file. E finché non si hanno decine di migliaia di file (le moderne shell supportano linee di comando veramente lunghe). Il tuo progetto ha 74 file, quindi hai molto spazio per crescere.


So che la domanda è etichettata come bash , ma sembra che il problema che stai cercando di risolvere sia anche relativo al PHP.

Sebastian Bergmann ha scritto uno strumento chiamato PHPLOC che fa ciò che vuoi e in più ti offre una panoramica della complessità di un progetto. Questo è un esempio del suo rapporto:

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

Come puoi vedere, le informazioni fornite sono molto più utili dal punto di vista di uno sviluppatore, perché ti può dire approssimativamente quanto sia complesso un progetto prima di iniziare a lavorare con esso.


Sui sistemi UNIX, c'è uno strumento chiamato cloc che fornisce statistiche sul codice.

Mi sono imbattuto in una directory casuale nella nostra base di codice che dice:

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

Uno semplice che sarà veloce, utilizzerà tutta la potenza di ricerca / filtraggio di find , non fail quando ci sono troppi file (overflow di argomenti numerici), funziona bene con file con simboli divertenti nel loro nome, senza usare xargs , non lo farà lancia un numero inutilmente alto di comandi esterni (grazie a + per find 's -exec ). Ecco qui:

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

solo per fonti:

wc `find`

per filtrare, basta usare grep

wc `find | grep .php$`

POSIX

A differenza della maggior parte delle altre risposte qui, queste funzionano su qualsiasi sistema POSIX, per qualsiasi numero di file e con qualsiasi nome di file (tranne dove indicato).

Linee in ogni file:

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

Linee in ogni file, ordinate per percorso file

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

Righe in ogni file, ordinate per numero di righe, discendenti

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

Linee totali in tutti i file

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




shell