Come contare ricorsivamente tutte le righe di codice in una directory?

Abbiamo un'applicazione PHP e vogliamo contare tutte le righe di codice in una directory specifica e nelle sue sottodirectory. Non abbiamo bisogno di ignorare i commenti, poiché stiamo solo cercando di ottenere un'idea approssimativa.

wc -l *.php 

Questo comando funziona benissimo in una determinata directory, ma ignora le sottodirectory. Stavo pensando che potrebbe funzionare, ma sta tornando 74, il che non è assolutamente il caso ...

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

Qual è la sintassi corretta per alimentare tutti i file?

Provare:

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

Anche lo strumento SLOCCount può essere d'aiuto.

Fornirà un accurato numero di righe di codice per qualsiasi gerarchia in cui lo punti, oltre ad alcune statistiche aggiuntive.

Uscita ordinata:

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

Per un altro one-liner:

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

funziona su nomi con spazi, genera solo un numero.

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

wc -l **/*.php

Nella shell Bash è necessario globstarimpostare l' opzione, altrimenti l' **operatore glob non è ricorsivo. Per abilitare questa impostazione, emettere

shopt -s globstar

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

È possibile utilizzare l' clocutilità creata per questo preciso scopo. Riporta 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
-------------------------------------------------------------------------------

Su sistemi simili a UNIX, esiste uno strumento chiamato clocche fornisce statistiche di 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
-------------------------------------------------------------------------------

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

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

Ancora un'altra variazione :)

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

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

Modifica2: aggiungi .dopo findper farlo funzionare

Sorprendentemente non c'è risposta basata su find -exece awk. Eccoci qui:

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

Questo frammento trova per tutti i file ( -type f). Per trovare per estensione, utilizzare -name:

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

Più comune e semplice per quanto mi riguarda, supponiamo che tu abbia bisogno di contare i file con diverse estensioni (diciamo, anche nativi)

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

Grazie per il feedback, l'ho corretto.

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

Righe in ciascun 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 {} +

Righe in ciascun file, ordinate per percorso del 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 ciascun file, ordinate per numero di righe, in ordine decrescente

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

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

Quello che vuoi è un semplice forciclo:

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

solo per fonti:

wc `find`

per filtrare, basta usare grep

wc `find | grep .php$`

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

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

So che la domanda è taggata come bash, ma sembra che il problema che stai cercando di risolvere sia legato anche a PHP.

Sebastian Bergmann ha scritto uno strumento chiamato PHPLOC che fa quello che vuoi e che ti fornisce 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é possono dirti approssimativamente quanto sia complesso un progetto prima di iniziare a lavorarci.

Supponendo che nessuno lo vedrà mai seppellito sul retro ... Eppure nessuna delle risposte finora arriva al problema dei nomi di file con spazi. Inoltre, tutto ciò che viene utilizzato xargsè soggetto a errori se la lunghezza totale dei percorsi nella struttura supera il limite delle dimensioni dell'ambiente di shell (il valore predefinito è qualche megabyte in Linux). Eccone uno che risolve questi problemi in modo piuttosto diretto. La subshell si occupa dei file con spazi. Il awktotale è il flusso dei singoli wcoutput dei file , quindi non dovrebbe mai rimanere senza spazio. Limita anche solo i execfile (saltando le directory):

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

WC-L? meglio usare GREP -C ^

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

se vuoi ancora linee di conteggio, 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 (conta entra, non linee !!!)

molto semplicemente

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

Se desideri che i risultati vengano ordinati in base al numero di righe, puoi semplicemente aggiungere | sorto | sort -r( -rper ordine decrescente) alla prima risposta, in questo modo:

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

Per Windows , lo strumento facile e veloce è LocMetrics .

Qualcosa di diverso:

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

Questo funziona bene, ma è necessario disporre di almeno un *.phpfile nella cartella corrente o in una delle sue sottocartelle, oppure wcbancarelle

Se sei su Linux (e credo che lo sia), raccomando il mio tool poliglotta . È drammaticamente più veloce di entrambi sloccounto cloced è più caratteristico di sloccount.

Puoi invocarlo con

poly .

o

poly

quindi è molto più user-friendly di alcuni script bash contorti.

È molto semplice con i globs zsh:

wc -l ./**/*.php

Se stai usando bash, devi solo aggiornare. Non c'è assolutamente alcun motivo per usare bash.

Lo strumento Tokei visualizza le statistiche sul codice in una directory. Tokei mostrerà il numero di file, le linee totali all'interno di quei file e codice, commenti e spazi raggruppati per lingua. Tokei è disponibile anche su Mac, Linux e Windows.

Un esempio dell'output di Tokei è il seguente:

$ 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 può essere installato seguendo le istruzioni sul file README nel repository .

Se hai bisogno solo del numero totale di righe in diciamo che i tuoi file PHP puoi usare un comando a riga singola molto semplice anche sotto Windows se hai GnuWin32 installato. Come questo:

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

È necessario specificare dove si trova find.exe, altrimenti verrà eseguito FIND.EXE (dai vecchi comandi simili a DOS) di Windows, poiché probabilmente è precedente a GnuWin32 nell'ambiente PATH e presenta parametri e risultati diversi.

Si noti che nel comando sopra è necessario utilizzare le virgolette, non le virgolette singole.

Distribuire prima i file più lunghi (ad es. Forse questi file lunghi richiedono un po 'di amore per il refactoring?) Ed escludere alcune directory dei fornitori:

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

Se vuoi mantenerlo semplice, ritaglia l'intermediario e chiama wccon 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 fintanto che non hai decine di migliaia di file (le shell moderne supportano righe di comando davvero lunghe). Il tuo progetto ha 74 file, quindi hai un sacco di spazio per crescere.

Non hai bisogno di tutti questi comandi complicati e difficili da ricordare. Hai solo bisogno di uno strumento chiamato line-counter .

Una rapida panoramica

Ecco come si ottiene lo strumento

$ pip install line-counter

Utilizzare il linecomando per ottenere il conteggio dei file e il conteggio delle righe nella directory corrente (ricorsivamente)

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

Se vuoi maggiori dettagli, basta usare 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 .gitignorecome configurare il file ad esso. È possibile impostare regole per selezionare o ignorare quale tipo di file contare esattamente come quello che si fa in '.gitignore'.

Ulteriori descrizioni e utilizzo sono disponibili qui: https://github.com/MorganZhang100/line-counter

Se i file sono troppi, meglio cercare solo il conteggio totale delle righe.

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

Almeno su OS X, i comandi find + xarg + wc elencati in alcune delle altre risposte vengono stampati "totali" più volte su elenchi di grandi dimensioni e non viene fornito un totale completo. Sono stato in grado di ottenere un singolo totale per i file .c utilizzando il seguente comando:

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