Conta il numero di righe in un repository git


766

Come contare il numero totale di righe presenti in tutti i file in un repository git?

git ls-files mi dà un elenco di file tracciati da git.

Sto cercando un comando per cattutti quei file. Qualcosa di simile a

git ls-files | [cat all these files] | wc -l

Risposte:


1141

xargs farà quello che vuoi:

git ls-files | xargs cat | wc -l

Ma con più informazioni e probabilmente meglio, puoi fare:

git ls-files | xargs wc -l

11
Immagino banale; Che ne dici di includere solo i file di codice sorgente (es. * .Cpp). Abbiamo impegnato alcuni file bin :)
Daniel,

39
Attaccati grep cpp |prima del xargs, quindi.
Carl Norum,

35
Utilizzare git ls-files -z | xargs -0 wc -lse si hanno file con spazi nel nome.
mpontillo,

34
Per includere / escludere determinati file usare: git ls-files | grep -P ".*(hpp|cpp)" | xargs wc -ldove la parte grep è qualsiasi regex perl che vuoi!
Gabriel,

29
Se eri interessato solo ai file .java puoi usaregit ls-files | grep "\.java$" | xargs wc -l
dseibert il

352
git diff --stat 4b825dc642cb6eb9a060e54bf8d69288fbee4904

Questo mostra le differenze dall'albero vuoto al tuo attuale albero di lavoro. Che succede a contare tutte le linee nel tuo attuale albero di lavoro.

Per ottenere i numeri nel tuo attuale albero di lavoro, procedi come segue:

git diff --shortstat `git hash-object -t tree /dev/null`

Ti darà una stringa come 1770 files changed, 166776 insertions(+).


45
A proposito, puoi ottenere l'hash correndo git hash-object -t tree /dev/null.
effimero

84
E ancora più git diff --stat `git hash-object -t tree /dev/null`
conciso

10
Questa è la migliore assunzione poiché non conta i file binari come archivi o immagini che sono conteggiati nella versione sopra!
BrainStone,

31
+1 Mi piace questa soluzione meglio poiché i binari non vengono conteggiati. Inoltre siamo davvero interessati all'ultima riga dell'uscita git diff:git diff --stat `git hash-object -t tree /dev/null` | tail -1
Gabriele Petronella,

31
invece usa git diff --shortstat `git hash-object -t tree /dev/null` per ottenere l'ultima riga, la coda non è necessaria.
Jim Wolff,

316

Se si desidera questo conteggio perché si desidera avere un'idea dell'ambito del progetto, è possibile preferire l'output di CLOC ("Count Lines of Code"), che fornisce una suddivisione di righe di codice significative e insignificanti per lingua.

cloc $(git ls-files)

(Questa riga equivale a git ls-files | xargs cloc. Usa shla $()sostituzione di comando funzione di .)

Uscita campione:

      20 text files.
      20 unique files.                              
       6 files ignored.

http://cloc.sourceforge.net v 1.62  T=0.22 s (62.5 files/s, 2771.2 lines/s)
-------------------------------------------------------------------------------
Language                     files          blank        comment           code
-------------------------------------------------------------------------------
Javascript                       2             13            111            309
JSON                             3              0              0             58
HTML                             2              7             12             50
Handlebars                       2              0              0             37
CoffeeScript                     4              1              4             12
SASS                             1              1              1              5
-------------------------------------------------------------------------------
SUM:                            14             22            128            471
-------------------------------------------------------------------------------

Dovrai prima installare CLOC. Probabilmente puoi installarlo cloccon il tuo gestore pacchetti, ad esempio brew install cloccon Homebrew .

cloc $(git ls-files)è spesso un miglioramento cloc .. Ad esempio, l'output di esempio sopra git ls-filesriportato riporta 471 righe di codice. Per lo stesso progetto, cloc .riporta 456.279 righe (e richiede sei minuti per l'esecuzione), perché cerca le dipendenze nella node_modulescartella ignorata da Git .


4
CLOC ignora alcune lingue, come TypeScript.
Marcelo Camargo,

6
@MarceloCamargo in questo momento è supportato TypeScript
Alexander

1
Per i principianti, è meglio eseguire "cloc DIRECTORY_WHERE_YOUR_GIT_IN" per calcolare le linee.
Shi,

La descrizione completa è qui: github.com/AlDanial/cloc ei binari sono qui: github.com/AlDanial/cloc/releases/tag/v1.70
Peter Szanto

15
Puoi semplicemente usare cloc --vcs gitquesti giorni, il che evita alcuni casi limite con file con nomi errati (o troppi di essi).
seanf

56

Ho riscontrato problemi di batch con git ls-files | xargs wc -lquando si ha a che fare con un numero elevato di file, in cui i conteggi delle righe verranno suddivisi in più totalrighe.

Prendere una mancia dalla domanda Perché l'utilità wc genera più righe con "totale"? , Ho trovato il seguente comando per aggirare il problema:

wc -l $(git ls-files)

O se si desidera esaminare solo alcuni file, ad esempio il codice:

wc -l $(git ls-files | grep '.*\.cs')


Questo è fantastico ma sembra fallire per i percorsi che contengono spazi bianchi. C'è un modo per risolverlo?
Lea Hayes,

1
Ho avuto problemi con grep '. * \. M' raccogliendo file binari come .mp3, .mp4. Ha avuto più successo con l'uso del comando find per elencare i file di codicewc -l $(git ls-files | find *.m *.h)
Tico Ballagas,

3
@LeaHayes questo è un modo: wc -l --files0-from=<(git ls-files -z). La <(COMMAND)sintassi restituisce il nome di un file il cui contenuto è il risultato diCOMMAND .
buck

@buck Grazie, ma ricevo un errore quando provo quel comando 'impossibile eseguire la sostituzione del processo: funzione non implementata wc: opzione non riconosciuta --files0-from ='. Qualche idea?
Lea Hayes,

1
@LeaHayes Ho ideato questo script che penso funzionerebbe per te: `` #! / Bin / bash results = $ (git ls-files | xargs -d '\ n' wc -l) let grand_total = 0 per x in $ (echo "$ results" | egrep '[[: digit:]] + total $'); let grand_total + = $ (echo "$ x" | awk '{print $ 1}') fatto echo "$ {results}" echo "totale generale: $ {grand_total}" `` `
buck

45

La soluzione migliore, secondo me, è sepolta nei commenti della risposta di @ephemient. Lo sto solo tirando su qui in modo che non passi inosservato. Il merito per questo dovrebbe andare a @FRoZeN (e @ephemient).

git diff --shortstat `git hash-object -t tree /dev/null`

restituisce il totale di file e linee nella directory di lavoro di un repository, senza alcun rumore aggiuntivo. Come bonus, viene conteggiato solo il codice sorgente - i file binari sono esclusi dal conteggio.

Il comando sopra funziona su Linux e OS X. La versione multipiattaforma è

git diff --shortstat 4b825dc642cb6eb9a060e54bf8d69288fbee4904

Funziona anche su Windows.

Per la cronaca, le opzioni per escludere le righe vuote,

  • -w/ --ignore-all-space,
  • -b/ --ignore-space-change,
  • --ignore-blank-lines,
  • --ignore-space-at-eol

non ha alcun effetto se usato con --shortstat . Vengono contate le righe vuote.


1
git mktree </dev/nullo true|git mktreeo git mktree <&-o :|git mktreeper i contatori di tasti tra noi :-) - un albero vuoto di riserva che galleggia intorno al repository non farà male a nulla.
Jill

2
Per le persone che si chiedono che cos'è quell'hashish di punto in bianco: stackoverflow.com/questions/9765453/…
Tejas Kale

19

Funziona a partire da cloc 1.68:

cloc --vcs=git


--vcsnon ha funzionato per me, forse è stato rimosso. cloc .mentre al repository git ha funzionato, OTOH.
acdcjunior,

13

Stavo giocando con cmder ( http://gooseberrycreative.com/cmder/ ) e volevo contare le righe di html, css, java e javascript. Mentre alcune delle risposte sopra hanno funzionato, lo orschema in grep non ha funzionato - ho trovato qui ( /unix/37313/how-do-i-grep-for-multiple-patterns ) che avevo per sfuggire

Quindi questo è quello che uso ora:

git ls-files | grep "\(.html\|.css\|.js\|.java\)$" | xargs wc -l


2
Questo sembrava rispondere a pezzi per me. L'utilizzo del grep in combinazione con la soluzione di Justin Aquadro mi ha dato buoni risultati. wc -l $ (git ls-files | grep "\ (. html \ | .css \ | .js \ | .php \ | .json \ | .sh \) $")
Peter Mark

9

Io uso il seguente:

git grep ^ | wc -l

Questo cerca in tutti i file controllati da git il regex ^, che rappresenta l'inizio di una riga, quindi questo comando fornisce il numero totale di righe!


3

L'ho fatto:

git ls-files | xargs file | grep "ASCII" | cut -d : -f 1 | xargs wc -l

funziona se si contano tutti i file di testo nel repository come file di interesse. Se alcuni sono considerati documentazione, ecc., È possibile aggiungere un filtro di esclusione.


3

Questo strumento su github https://github.com/flosse/sloc può fornire l'output in modo più descrittivo. Creerà le statistiche del tuo codice sorgente:

  • linee fisiche
  • righe di codice (sorgente)
  • righe con commenti
  • commenti a riga singola
  • righe con commenti a blocchi
  • righe mescolate con fonte e commenti
  • linee vuote

1

Provare:

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

nella directory / directory in questione


0
: | git mktree | git diff --shortstat --stdin

O:

git ls-tree @ | sed '1i\\' | git mktree --batch | xargs | git diff-tree --shortstat --stdin

0

A seconda che tu voglia o meno includere file binari, ci sono due soluzioni.

  1. git grep --cached -al '' | xargs -P 4 cat | wc -l
  2. git grep --cached -Il '' | xargs -P 4 cat | wc -l

    "xargs -P 4" significa che può leggere i file usando quattro processi paralleli. Questo può essere davvero utile se stai eseguendo la scansione di repository di grandi dimensioni. A seconda della capacità della macchina è possibile aumentare il numero di processi.

    -a, elabora i file binari come testo (Includi binari)
    -l '', mostra solo i nomi dei file anziché le righe corrispondenti (Scansiona solo i file non vuoti)
    -I, non corrisponde ai pattern nei file binari (Escludi binario) -
    cache, cerca nell'indice anziché nell'albero di lavoro (Includi file non registrati)

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.