Comment compter récursivement toutes les lignes de code d'un répertoire?


1625

Nous avons une application PHP et nous voulons compter toutes les lignes de code sous un répertoire spécifique et ses sous-répertoires. Nous n'avons pas besoin d'ignorer les commentaires, car nous essayons simplement d'avoir une idée approximative.

wc -l *.php 

Cette commande fonctionne très bien dans un répertoire donné, mais ignore les sous-répertoires. Je pensais que cela pourrait fonctionner, mais il revient 74, ce qui n'est certainement pas le cas ...

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

Quelle est la syntaxe correcte pour alimenter tous les fichiers?

Réponses:


2651

Essayer:

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

L'outil SLOCCount peut également vous aider.

Il donnera un décompte précis des lignes de code source pour la hiérarchie vers laquelle vous le dirigez, ainsi que des statistiques supplémentaires.

Sortie triée:

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


31
cloc.sourceforge.net pourrait être intéressant comme alternative à sloccount (plus de langues mais moins d'informations)
AsTeR

31
avec les fichiers include également:find . -name '*.php' -o -name '*.inc' | xargs wc -l
rymo

52
Cela imprimera plus d'un numéro lorsqu'il y a beaucoup de fichiers (car wcsera exécuté plusieurs fois. Ne gère pas non plus de nombreux noms de fichiers spéciaux.
l0b0

42
@idober:find . -name "*.php" -not -path "./tests*" | xargs wc -l
endre

19
Si un nom de répertoire contient des espaces ... la commande ci-dessus échoue !!
nitish712

474

Pour un autre doublure:

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

fonctionne sur les noms avec des espaces, ne produit qu'un seul nombre.


1
+1 idem ... recherché pour toujours ... toutes les autres commandes "find" n'ont renvoyé que le nombre de fichiers réels .... le truc -print0 ici a obtenu le nombre de lignes réel pour moi !!! Merci!
Ronedog

3
@ TorbenGundtofte-Bruun - voir man find.. print0 avec xargs -0 vous permet d'opérer sur des fichiers qui ont des espaces ou d'autres caractères étranges en leur nom
Shizzmo

2
@ TorbenGundtofte-Bruun - aussi, le -0 en xargs correspond à print0, c'est une sorte d'encodage / décodage pour gérer les espaces.
Tristan Reid

7
Si vous avez besoin de plus d'un filtre de nom, j'ai trouvé que (au moins avec la version MSYSGit de find), vous avez besoin de parens supplémentaires: ( find . \( -name '*.h' -o -name '*.cpp' \) -print0 | xargs -0 cat ) | wc -l
Zrax

1
@DesignbyAdrian: la journalisation aide à la récupération après incident, pas à la vitesse. Il est probable que vous constatiez de bonnes performances en raison de la mise en cache ou d'un disque dur très rapide.
jmh

398

Si vous utilisez une version décemment récente de Bash (ou ZSH), c'est beaucoup plus simple:

wc -l **/*.php

Dans le shell Bash, cela nécessite que l' globstaroption soit définie, sinon l' **opérateur glob n'est pas récursif. Pour activer ce paramètre, émettez

shopt -s globstar

Pour le rendre permanent, ajoutez-le à l'un des fichiers d'initialisation ( ~/.bashrc, ~/.bash_profileetc.).


7
Je vote pour la simplicité, mais je veux juste souligner qu'il ne semble pas rechercher les répertoires de manière récursive, il vérifie uniquement les sous-répertoires du répertoire actuel. C'est sur SL6.3.
Godric Seer

7
Cela dépend de votre shell et des options que vous avez définies. Bash doit globstarêtre défini pour que cela fonctionne.
Michael Wild

2
@PeterSenna, avec l'archive actuelle du noyau 3.9.8, la commande wc -l **/*.[ch]trouve un total de 15195373 lignes. Je ne sais pas si vous considérez que c'est une "très faible valeur". Encore une fois, vous devez vous assurer que vous avez globstaractivé dans Bash. Vous pouvez vérifier avec shopt globstar. Pour l'activer explicitement, faites shopt -s globstar.
Michael Wild

5
@MichaelWild C'est une bonne solution, mais elle débordera toujours ARG_MAXsi vous avez un grand nombre de .phpfichiers, car elle wcn'est pas intégrée.
Réinstallez Monica Please le

1
@AlbertSamuel Non, vous devez comparer la liste des fichiers produits par les deux méthodes. Ma méthode a le problème de ne pas fonctionner pour un grand nombre de fichiers, comme mentionné par @BroSlow. La réponse acceptée échouera si les chemins produits par findcontiennent des espaces. Cela pourrait être fixé à l'aide print0et --nullles findet les xargsappels, respectivement.
Michael Wild

363

Vous pouvez utiliser l' clocutilitaire conçu à cet effet précis. Il indique à chacun le nombre de lignes dans chaque langue, ainsi que le nombre de commentaires, etc. CLOC est disponible sur Linux, Mac et Windows.

Exemple d'utilisation et de sortie:

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

4
C'est un bel outil qui fonctionne bien et donne rapidement des statistiques utiles à la fin. Aimer.
Rob Forrest

4
Notez que vous pouvez exécuter des commandes Unix sous Windows à l'aide de cygwin (ou d'autres ports / environnements similaires). Pour moi, avoir ce type d'accès si extrêmement utile, c'est une nécessité. Une ligne de commande Unix est magique. J'aime particulièrement perl et les expressions régulières.
Curtis Yallop

CLOC et SLOCCount fonctionnent correctement sur le macbook mi-2015. Notez que leurs nombres sont proches mais pas exactement les mêmes pour le projet Android 127k Java. Notez également que l'équivalent iOS avait 2x la LoC; donc, la métrique "coût" dans SLOCCount peut être désactivée (ou peut-être que les développeurs iOS font 2x ce que les développeurs Android font. :-)
maxweber

2
Envisageriez-vous de modifier le début de cette question pour qu'il soit clair qu'il clocs'agit d'une plateforme multiplateforme puisqu'il ne s'agit que d'un script Perl?
Kyle Strand

Tout simplement parfait, fonctionne très bien dans Windows bash bien sûr.
yurisnm

100

Sur les systèmes de type UNIX, il existe un outil appelé clocqui fournit des statistiques de code.

Je suis tombé sur un répertoire aléatoire dans notre base de code, il dit:

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

2
@moose techniquement simtao l'a mentionné spécifiquement comme une solution pour les utilisateurs de Windows, sans mentionner du tout linux ou unix.
Tim Seguine

5
@moose Table a été modifié dans sa réponse bien plus tard que ma réponse, maintenant les deux se ressemblent en effet.
Calmarius

Je l'aime. cloc est vraiment soigné. Mais que signifie ce nom?
Manoel Vilela

C'est aussi sur Windows maintenant! En supposant que vous avez du chocolat :choco install cloc
icc97

35

Vous n'avez pas spécifié le nombre de fichiers ou la sortie souhaitée. Est-ce ce que vous recherchez:

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

2
Cela fonctionnera tant qu'il n'y aura pas trop de fichiers: s'il y a beaucoup de fichiers, vous obtiendrez ainsi plusieurs lignes (xargs divisera la liste des fichiers en plusieurs sous-listes)
Pascal MARTIN

Ah oui. C'est pourquoi j'ai dit qu'il n'avait pas précisé combien de fichiers il y avait. Ma version est plus facile à retenir, mais la version de Shin est meilleure si vous avez plus de quelques fichiers. Je vote.
Paweł Polewicz

Je devais adapter ce pour une utilisation dans une fonction, où des guillemets simples sont trop restrictives: Les go () { mkdir /tmp/go; [[ -f ./"$1" ]] && mv ./"$1" /tmp/go; (find ./ -type f -name "$*" -print0 | xargs -0 cat ) | wc -l; wc -l /tmp/go/*; mv /tmp/go/* . } résultats ont été près de slocount pour *.py, mais il ne le savais pas *.js, *.html.
jalanb

31

Encore une autre variation :)

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

Modifier: cela donnera la somme totale, au lieu de fichier par fichier.

Edit2: Ajouter .après findpour le faire fonctionner


les deux réponses résument les lignes.
josh123a123

Au moins à cygwin, j'ai eu de meilleurs résultats avec:$ find -name \*\.php -print0 | xargs -0 cat | wc -l
Martin Haeberli

sur Darwin, cela donne juste un grand total: find . -name '*.php' | xargs cat | wc -l... alors que cela donne fichier par fichier et un grand total:find . -name '*.php' | xargs wc -l
OsamaBinLogin

30

Étonnamment, il n'y a pas de réponse basée sur les trouvailles -execet awk. Et c'est parti:

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

Cet extrait trouve pour tous les fichiers ( -type f). Pour rechercher par extension de fichier, utilisez -name:

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

2
Fonctionnellement, cela fonctionne parfaitement, mais sur une grande liste (source Linux), c'est vraiment lent car il démarre un processus wc pour chaque fichier au lieu d'un processus wc pour tous les fichiers. Je l'ai chronométré à 31 secondes en utilisant cette méthode, contre 1,5 seconde en utilisant find . -name '*.c' -print0 |xargs -0 wc -l. Cela dit, cette méthode plus rapide (au moins sur OS X), finit par imprimer "total" plusieurs fois, donc un filtrage supplémentaire est nécessaire pour obtenir un total correct (j'ai publié des détails dans ma réponse).
Doug Richardson,

Cela a l'avantage de fonctionner pour un nombre illimité de fichiers. Bien joué!
ekscrypto

1
c'est une bien meilleure solution une fois que vous travaillez avec une grande quantité de Go et de fichiers. en faire un wcsur une forme de catest lent car le système doit d'abord traiter tous les Go pour commencer à compter les lignes (testé avec 200 Go de jsons, 12k fichiers). faire d' wcabord puis compter le résultat est beaucoup plus rapide
ulkas

1
@DougRichardson, vous pouvez envisager ceci à la place: find . -type f -exec wc -l {} \+ou find . -name '*.py' -type f -exec wc -l {} \+ qui imprime un total à la fin de la sortie. Si tout ce qui vous intéresse est le total, vous pouvez aller un peu plus loin et utiliser tail: find . -type f -exec wc -l {} \+ | tail -1oufind . -name '*.py' -type f -exec wc -l {} \+ | tail -1
JamieJag

25

Plus commun et simple que pour moi, supposons que vous ayez besoin de compter les fichiers de différentes extensions de nom (disons, aussi natifs)

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

Merci pour le retour, je l'ai corrigé.


6
cela ne fait pas tout à fait ce que vous pensez. trouver . -name ' . [am]' est identique à trouver. -name ' . [a | m]' les deux trouveront tous les fichiers se terminant par .m ou .a
Omry Yadan

1
mais le second trouvera également des fichiers se terminant par. , si seulement. Donc [h | c | cpp | php | cc] finit par être le même que [hcp |].
OsamaBinLogin

les backticks sont déconseillés, préfèrent$()
Sandburg

Cela fonctionne sous Cygwin. Bien sûr, le lecteur "C: \" doit suivre la convention cygwin, comme par exemple: wc $ (find / cygdrive / c // SomeWindowsFolderj / -type f | egrep "\. (H | c | cpp | php | cc) ")
Christian Gingras

21

POSIX

Contrairement à la plupart des autres réponses ici, celles-ci fonctionnent sur n'importe quel système POSIX, pour n'importe quel nombre de fichiers et avec n'importe quel nom de fichier (sauf indication contraire).


Lignes dans chaque fichier:

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

Lignes dans chaque fichier, triées par chemin de fichier

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

Lignes dans chaque fichier, triées par nombre de lignes, décroissantes

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

Nombre total de lignes dans tous les fichiers

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

19

Il existe un petit outil appelé sloccount pour compter les lignes de code dans le répertoire. Il convient de noter qu'il fait plus que vous le souhaitez car il ignore les lignes / commentaires vides, regroupe les résultats par langage de programmation et calcule des statistiques.


Pour Windows, LocMetrics fait le travail
Camille

15

Ce que vous voulez, c'est une simple forboucle:

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

3
n'est-ce pas exagéré par rapport aux réponses qui le suggèrent xargs?
Nathan Fellman

5
Non, Nathan. Les réponses xargs n'imprimeront pas nécessairement le nombre sous la forme d'un nombre unique. Il peut simplement imprimer un tas de sous-totaux.
Rob Kennedy

3
que fera ce programme si les noms de fichiers contiennent des espaces? Et les nouvelles lignes? ;-)
Paweł Polewicz

38
Si vos noms de fichiers contiennent de nouvelles lignes, je dirais que vous avez de plus gros problèmes.
Kzqai

2
@ennuikiller Nombre de problèmes avec cela, tout d'abord, il se cassera sur les fichiers avec des espaces blancs. La définition IFS=$'\n'avant la boucle le corrigerait au moins pour tous, sauf les fichiers avec des retours à la ligne dans leurs noms. Deuxièmement, vous ne citez pas '*.php', il sera donc développé par le shell et non find, et ergo ne trouvera en fait aucun des fichiers php dans les sous-répertoires. Le -printest également redondant, car il est implicite en l'absence d'autres actions.
Réinstallez Monica Please le

12

pour les sources uniquement:

wc `find`

pour filtrer, utilisez simplement grep

wc `find | grep .php$`

11

Un simple qui sera rapide, utilisera toute la puissance de recherche / filtrage de find, n'échouera pas quand il y a trop de fichiers (débordements d'arguments numériques), fonctionne correctement avec des fichiers avec des symboles amusants en leur nom, sans utiliser xargs, ne lancera pas un nombre inutilement élevé de commandes externes (grâce à +de findl » -exec). Voici:

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

2
J'étais sur le point de publier une variante de cela moi-même (avec \;au lieu de +comme je ne le savais pas), cette réponse devrait être la bonne réponse.
Mark K Cowan

7

Je sais que la question est étiquetée comme , mais il semble que le problème que vous essayez de résoudre soit également lié à PHP.

Sebastian Bergmann a écrit un outil appelé PHPLOC qui fait ce que vous voulez et en plus de cela, vous donne un aperçu de la complexité d'un projet. Voici un exemple de son rapport:

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

Comme vous pouvez le voir, les informations fournies sont beaucoup plus utiles du point de vue d'un développeur, car elles peuvent vous dire à peu près à quel point un projet est complexe avant de commencer à travailler avec lui.


7

Je suppose que personne ne verra jamais cela enfoui à l'arrière ... Pourtant, aucune des réponses n'a jusqu'à présent abordé le problème des noms de fichiers avec des espaces. De plus, toutes ces utilisations xargssont susceptibles d'échouer si la longueur totale des chemins dans l'arborescence dépasse la limite de taille de l'environnement shell (par défaut, quelques mégaoctets sous Linux). En voici un qui résout ces problèmes de manière assez directe. Le sous-shell s'occupe des fichiers avec des espaces. Le awktotal du flux de wcsorties de fichiers individuels , ne doit donc jamais manquer d'espace. Il limite également les execfichiers uniquement (en ignorant les répertoires):

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

6

WC -L? mieux utiliser GREP -C ^

wc -l? Faux! La commande wc compte les nouveaux codes de lignes, pas les lignes! Lorsque la dernière ligne du fichier ne se termine pas avec un nouveau code de ligne, cela ne comptera pas!

si vous voulez toujours compter les lignes, utilisez grep -c ^ , exemple complet:

#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

enfin, attention au piège wc -l (le nombre entre, pas les lignes !!!)


Veuillez lire la définition POSIX d'une ligne . Avec grep -c ^vous comptez le nombre de lignes incomplètes , et ces lignes incomplètes ne peuvent pas apparaître dans un fichier texte .
gniourf_gniourf

2
Je sais cela. En pratique, seule la dernière ligne peut être incomplète car elle n'a pas de fin de vie. L'idée compte toutes les lignes, y compris une incomplète. C'est une erreur très fréquente, ne comptant que des lignes complètes. après avoir compté, nous pensons "pourquoi j'ai raté la dernière ligne ???". C'est pourquoi, et recette comment le faire correctement.
Znik

Ou, si vous voulez une doublure: find -type f -name '*.php' -print0 | xargs -0 grep -ch ^ | paste -sd+ - | bc voir ici pour des alternatives à bc: stackoverflow.com/q/926069/2400328
techniao

4

très simplement

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

1
il échouera s'il y a un espace ou une nouvelle ligne dans l'un des noms de fichiers
Paweł Polewicz

4

Si vous voulez que vos résultats soient triés par nombre de lignes, vous pouvez simplement ajouter | sortou | sort -r( -rpour l'ordre décroissant) à la première réponse, comme ceci:

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

1
Puisque la sortie de xargs wc -lest numérique, il faudrait en fait utiliser sort -nou sort -nr.
Dustin Ingram

4

Pour Windows , LocMetrics est un outil simple et rapide .


Il est peu probable que OP soit sous Windows s'ils utilisent bash.

1
Le titre et la description de la question @VanessaMcHale ne nécessitent pas clairement une solution uniquement Unix. Une solution basée sur Windows est donc acceptable. Google m'a également indiqué cette page lorsque je cherchais une solution similaire.
walv

Ce commentaire m'a aidé. J'ai essayé ça et ça marche bien.
Allan F

4

Quelque chose de différent:

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

Cela fonctionne très bien, mais vous devez avoir au moins un *.phpfichier dans le dossier en cours ou l'un de ses sous-dossiers, sinon des wcdécrochages


peut aussi déborder ARG_MAX
Mark K Cowan

4

Si vous êtes sous Linux (et je suppose que vous l'êtes), je recommande mon outil polyglotte . Il est considérablement plus rapide que l'un sloccountou l' autre clocet il est plus fonctionnel que sloccount.

Vous pouvez l'invoquer avec

poly .

ou

poly

il est donc beaucoup plus convivial que certains scripts bash alambiqués.


4

C'est très simple avec les globes zsh:

wc -l ./**/*.php

Si vous utilisez bash, il vous suffit de mettre à niveau. Il n'y a absolument aucune raison d'utiliser bash.


4

L'outil Tokei affiche des statistiques sur le code dans un répertoire. Tokei affichera le nombre de fichiers, le nombre total de lignes dans ces fichiers et le code, les commentaires et les espaces groupés par langue. Tokei est également disponible sur Mac, Linux et Windows.

Un exemple de la sortie de Tokei est le suivant:

$ 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 peut être installé en suivant les instructions du fichier README dans le référentiel .


1
Cela devrait être la réponse acceptée
Elijas

3

Si vous n'avez besoin que du nombre total de lignes dans, disons vos fichiers PHP, vous pouvez utiliser une commande d'une ligne très simple même sous Windows si vous avez installé GnuWin32. Comme ça:

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

Vous devez spécifier où se trouve exactement le find.exe sinon le FIND.EXE fourni par Windows (à partir des anciennes commandes de type DOS) sera exécuté, car il est probablement avant le GnuWin32 dans le PATH de l'environnement, et a des paramètres et des résultats différents.

Veuillez noter que dans la commande ci-dessus, vous devez utiliser des guillemets, pas des guillemets simples.


Dans l'exemple ci-dessus, j'utilise le bash pour Windows au lieu du cmd.exe, c'est pourquoi il y a des barres obliques "/" et non des barres obliques "\".
Neven Boyanov

3

Donner d'abord les fichiers les plus longs (c.-à-d. Peut-être que ces longs fichiers ont besoin d'un peu de refactoring?), Et exclure certains répertoires de fournisseurs:

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

3

Si vous voulez rester simple, découpez l'intermédiaire et appelez simplement wcavec tous les noms de fichiers:

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

Ou dans la syntaxe moderne:

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

Fonctionne tant qu'il n'y a aucun espace dans les noms de répertoire ou les noms de fichiers. Et tant que vous n'avez pas des dizaines de milliers de fichiers (les shells modernes prennent en charge de très longues lignes de commande). Votre projet contient 74 fichiers, vous avez donc beaucoup d'espace pour vous développer.


J'aime celui la! Si vous êtes dans un environnement C / C ++ hybride:wc -l `find . -type f \( -name "*.cpp" -o -name "*.c" -o -name "*.h" \) -print`
Bram

a été surpris que ce ne soit pas la meilleure réponse
ms4720

3

Vous n'avez pas besoin de toutes ces commandes compliquées et difficiles à mémoriser. Vous avez juste besoin d'un outil appelé compteur de lignes .

Un aperçu rapide

Voici comment vous obtenez l'outil

$ pip install line-counter

Utilisez la linecommande pour obtenir le nombre de fichiers et le nombre de lignes dans le répertoire actuel (récursivement)

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

Si vous voulez plus de détails, utilisez simplement 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

Et la meilleure partie de cet outil est que vous pouvez y ajouter .gitignoreun fichier de configuration similaire. Vous pouvez définir des règles pour sélectionner ou ignorer le type de fichiers à compter, tout comme ce que vous faites dans «.gitignore».

Plus de description et d'utilisation sont ici: https://github.com/MorganZhang100/line-counter


3

Si les fichiers sont trop nombreux, mieux vaut simplement rechercher le nombre total de lignes.

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

2

Sur OS X au moins, les commandes find + xarg + wc répertoriées dans certaines des autres réponses impriment plusieurs fois "total" sur de grandes listes, et aucun total complet n'est donné. J'ai pu obtenir un total unique pour les fichiers .c en utilisant la commande suivante:

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

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.