Compter le nombre de lignes dans un référentiel git


766

Comment compter le nombre total de lignes présentes dans tous les fichiers d'un référentiel git?

git ls-files me donne une liste des fichiers suivis par git.

Je recherche une commande pour cattous ces fichiers. Quelque chose comme

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

Réponses:


1141

xargs fera ce que vous voulez:

git ls-files | xargs cat | wc -l

Mais avec plus d'informations et probablement mieux, vous pouvez faire:

git ls-files | xargs wc -l

11
Je suppose que c'est trivial; Que diriez-vous d'inclure uniquement les fichiers de code source (par exemple * .cpp). Nous avons des fichiers bin engagés :)
Daniel

39
Restez- grep cpp |y avant le xargs, alors.
Carl Norum

35
À utiliser git ls-files -z | xargs -0 wc -lsi vous avez des fichiers avec des espaces dans le nom.
mpontillo

34
Pour inclure / exclure certains fichiers, utilisez: git ls-files | grep -P ".*(hpp|cpp)" | xargs wc -loù la partie grep est toute expression rationnelle de perl que vous voulez!
Gabriel

29
Si vous n'étiez intéressé que par les fichiers .java, vous pouvez les utilisergit ls-files | grep "\.java$" | xargs wc -l
dseibert

352
git diff --stat 4b825dc642cb6eb9a060e54bf8d69288fbee4904

Cela montre les différences entre l'arborescence vide et votre arborescence de travail actuelle. Ce qui arrive à compter toutes les lignes de votre arbre de travail actuel.

Pour obtenir les nombres dans votre arborescence de travail actuelle, procédez comme suit:

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

Cela vous donnera une chaîne comme 1770 files changed, 166776 insertions(+).


45
BTW, vous pouvez obtenir ce hachage en exécutant git hash-object -t tree /dev/null.
éphémère du

84
Et encore plus succinct:git diff --stat `git hash-object -t tree /dev/null`
rpetrich

10
C'est la meilleure solution car cela ne compte pas les fichiers binaires comme les archives ou les images qui sont comptés dans la version ci-dessus!
BrainStone

31
+1 J'aime mieux cette solution car les binaires ne sont pas comptés. De plus, nous sommes vraiment intéressés par la dernière ligne de la sortie git diff:git diff --stat `git hash-object -t tree /dev/null` | tail -1
Gabriele Petronella

31
utilisez plutôt git diff --shortstat `git hash-object -t tree /dev/null` pour obtenir la dernière ligne, la queue n'est pas nécessaire.
Jim Wolff

316

Si vous voulez ce compte parce que vous voulez avoir une idée de la portée du projet, vous pouvez préférer la sortie de CLOC («Count Lines of Code»), qui vous donne une ventilation des lignes de code significatives et insignifiantes par langue.

cloc $(git ls-files)

(Cette ligne est équivalente à git ls-files | xargs cloc. Elle utilise shla fonction de $()substitution de commandes de .)

Exemple de sortie:

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

Vous devrez d'abord installer CLOC. Vous pouvez probablement installer clocavec votre gestionnaire de paquets - par exemple, brew install clocavec Homebrew .

cloc $(git ls-files)est souvent une amélioration cloc .. Par exemple, l'exemple de sortie ci-dessus avec git ls-files471 lignes de code de rapport. Pour le même projet, cloc .signale un énorme 456 279 lignes (et prend six minutes pour s'exécuter), car il recherche les dépendances dans le node_modulesdossier ignoré par Git .


4
CLOC ignore certains langages, tels que TypeScript.
Marcelo Camargo

6
@MarceloCamargo en ce moment TypeScript est pris en charge
Alexander

1
Pour le débutant, mieux vaut exécuter "cloc DIRECTORY_WHERE_YOUR_GIT_IN" pour calculer les lignes.
Shi

La description complète est ici: github.com/AlDanial/cloc et les binaires sont ici: github.com/AlDanial/cloc/releases/tag/v1.70
Peter Szanto

15
Vous pouvez simplement utiliser cloc --vcs gitces jours-ci, ce qui évite certains cas marginaux avec des fichiers mal nommés (ou trop nombreux).
seanf

56

J'ai rencontré des problèmes de git ls-files | xargs wc -ltraitement par lots lors du traitement d'un grand nombre de fichiers, où le nombre de lignes est divisé en plusieurs totallignes.

Prendre un conseil à la question Pourquoi l'utilitaire wc génère-t-il plusieurs lignes avec "total"? , J'ai trouvé la commande suivante pour contourner le problème:

wc -l $(git ls-files)

Ou si vous souhaitez examiner uniquement certains fichiers, par exemple le code:

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


C'est très bien mais cela semble échouer pour les chemins qui contiennent des espaces blancs. Y a-t-il un moyen de résoudre cela?
Lea Hayes

1
A rencontré des problèmes avec grep '. * \. M' pour récupérer des fichiers binaires comme .mp3, .mp4. A eu plus de succès avec la commande find pour lister les fichiers de codewc -l $(git ls-files | find *.m *.h)
Tico Ballagas

3
@LeaHayes c'est une façon: wc -l --files0-from=<(git ls-files -z). La <(COMMAND)syntaxe renvoie le nom d'un fichier dont le contenu est le résultat de COMMAND.
buck

@buck Merci, mais j'obtiens une erreur lorsque j'essaie cette commande 'ne peut pas créer de canal pour la substitution de processus: fonction non implémentée wc: option non reconnue --files0-from ='. Des idées?
Lea Hayes

1
@LeaHayes J'ai trouvé ce script qui, selon moi, fonctionnerait pour vous: `` `# # / bin / bash results = $ (git ls-files | xargs -d '\ n' wc -l) let grand_total = 0 for x dans $ (echo "$ results" | egrep '[[: digit:]] + total $'); laissez grand_total + = $ (echo "$ x" | awk '{print $ 1}') fait echo "$ {results}" echo "grand total: $ {grand_total}" `` `
buck

45

La meilleure solution, pour moi en tout cas, est enterrée dans les commentaires de la réponse de @ ephemient. Je le tire juste ici pour qu'il ne passe pas inaperçu. Le mérite en revient à @FRoZeN (et @ephemient).

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

renvoie le total des fichiers et des lignes dans le répertoire de travail d'un dépôt, sans aucun bruit supplémentaire. En prime, seul le code source est compté - les fichiers binaires sont exclus du décompte.

La commande ci-dessus fonctionne sous Linux et OS X. La version multiplateforme de celle-ci est

git diff --shortstat 4b825dc642cb6eb9a060e54bf8d69288fbee4904

Cela fonctionne aussi sur Windows.

Pour mémoire, les options pour exclure les lignes vides,

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

n'ont aucun effet lorsqu'il est utilisé avec --shortstat. Les lignes vides sont comptées.


1
git mktree </dev/nullou true|git mktreeou git mktree <&-ou :|git mktreepour les compteurs de touches parmi nous :-) - un arbre vide de rechange flottant autour du dépôt ne va rien faire de mal.
2015

2
Pour les gens qui se demandent ce qu'est le hachage à l' improviste
Tejas Kale

19

Cela fonctionne à partir du cloc 1.68:

cloc --vcs=git


--vcsn'a pas fonctionné pour moi, peut-être qu'il a été supprimé. cloc .tandis qu'au git repo a fonctionné, OTOH.
acdcjunior

13

Je jouais avec cmder ( http://gooseberrycreative.com/cmder/ ) et je voulais compter les lignes html, css, java et javascript. Alors que certaines des réponses ci-dessus fonctionnaient, le ormodèle dans grep ne fonctionnait pas - j'ai trouvé ici ( /unix/37313/how-do-i-grep-for-multiple-patterns ) que j'avais pour y échapper

Voici donc ce que j'utilise maintenant:

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


2
Cela a semblé répondre avec des morceaux pour moi. Utiliser votre grep en combinaison avec la solution de Justin Aquadro a bien fonctionné pour moi. wc -l $ (git ls-files | grep "\ (. html \ | .css \ | .js \ | .php \ | .json \ | .sh \) $")
Peter Mark

9

J'utilise ce qui suit:

git grep ^ | wc -l

Cela recherche tous les fichiers versionnés par git pour l'expression régulière ^, qui représente le début d'une ligne, donc cette commande donne le nombre total de lignes!


3

J'ai fait ça:

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

cela fonctionne si vous comptez tous les fichiers texte du référentiel comme fichiers d'intérêt. Si certains sont considérés comme de la documentation, etc., un filtre d'exclusion peut être ajouté.


3

Cet outil sur github https://github.com/flosse/sloc peut donner la sortie de manière plus descriptive. Il créera des statistiques de votre code source:

  • lignes physiques
  • lignes de code (source)
  • lignes avec commentaires
  • commentaires sur une seule ligne
  • lignes avec des commentaires de bloc
  • lignes mélangées avec la source et les commentaires
  • lignes vides

1

Essayer:

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

sur le répertoire / répertoires en question


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

Ou:

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

0

Selon que vous souhaitez ou non inclure des fichiers binaires, il existe deux solutions.

  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" signifie qu'il peut lire les fichiers en utilisant quatre processus parallèles. Cela peut être très utile si vous analysez de très grands référentiels. Selon la capacité de la machine, vous pouvez augmenter le nombre de processus.

    -a, traite les fichiers binaires sous forme de texte (Inclure les binaires)
    -l '', affiche uniquement les noms de fichiers au lieu des lignes correspondantes (Analyse uniquement les fichiers non vides)
    -I, ne correspond pas aux modèles des fichiers binaires (Exclure les binaires)
    --cached, rechercher dans l'index plutôt que dans l'arborescence de travail (inclure les fichiers non validés)

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.