Comment compter toutes les lignes de code dans un répertoire de manière récursive?

Nous avons une application PHP et 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 à utiliser dans tous les fichiers?

Essayer:

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

L’outil SLOCCount peut également vous aider.

Il fournira des lignes de comptage de code source précises pour toute hiérarchie que vous lui indiquerez, ainsi que des statistiques supplémentaires.

Pour un autre one-liner:

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

travaille sur les noms avec des espaces, ne produit qu’un numéro.

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

 wc -l **/*.php 

Dans le shell Bash, l’option globstar doit être définie, sinon l’opérateur ** glob n’est pas récursif. Pour activer ce paramètre, émettez

 shopt -s globstar 

Pour rendre ce permanent permanent, ajoutez-le à l’un des fichiers d’initialisation ( ~/.bashrc , ~/.bash_profile etc.).

Vous pouvez utiliser l’utilitaire cloc qui est conçu à cet effet. Il rapporte chaque quantité de lignes dans chaque langue, ainsi que le nombre de commentaires, etc.

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

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

J’ai couru sur un répertoire aléatoire dans notre base de code:

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

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

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

Encore une autre variation 🙂

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

Edit: cela donnera la sum totale, au lieu de fichier par fichier.

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 ne le souhaitez car il ignore les lignes / commentaires vides, regroupe les résultats par langage de programmation et calcule certaines statistiques.

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

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

POSIX

Lignes dans chaque fichier:

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

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

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

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

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

Total des lignes dans tous les fichiers

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

Étonnamment, il n’y a pas de réponse basée sur find -exec et awk . Et c’est parti:

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

Cet extrait de code 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 }' 

Un simple qui sera rapide, utilisera toute la puissance de recherche / filtrage de find , pas d’échec quand il ya trop de fichiers (débordement des arguments numériques), fonctionne bien avec des fichiers avec des symboles amusants dans leur nom, sans utiliser xargs , ne sera pas lancer un nombre inutilement élevé de commandes externes (grâce à + pour find ‘s -exec ). Voici:

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

pour les sources seulement:

 wc `find` 

pour filtrer, utilisez simplement grep

 wc `find | grep .php$` 

ce que vous voulez, c’est une simple boucle:

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

Vous pouvez également essayer CLOC (nécessite Perl)

Deviner que personne ne verra jamais cela enterré à l’arrière … Pourtant, aucune des réponses obtenues jusqu’à présent ne résout le problème des noms de fichiers avec des espaces. De plus, tous ceux qui utilisent xargs sont sujets à échec 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 corrige ces problèmes de manière assez directe. Le sous-shell prend en charge les fichiers avec des espaces. L’ awk totalise le stream de sorties individuelles des fichiers wc , ne devrait donc jamais manquer d’espace. Il restreint également l’exécutable aux fichiers uniquement (répertoires ignorés):

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

Je sais que la question est étiquetée comme bash , 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, 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 sharepoint vue d’un développeur, car elles peuvent vous dire à quel point un projet est complexe avant de commencer à travailler avec lui.

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 par un nouveau code de ligne, cela ne sera pas pris en compte!

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, faites attention au piège wc -l (les comptages entrent, pas les lignes !!!)

Si vous souhaitez que vos résultats soient sortingés par nombre de lignes, vous pouvez simplement append | sort | sort ou | sort -r | sort -r ( -r pour l’ordre décroissant) à la première réponse, comme ceci:

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

Quelque chose de différent:

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

Cela fonctionne bien, mais vous devez avoir au moins un fichier *.php dans le dossier en cours ou dans l’un de ses sous-dossiers, ou bien wc stalls

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

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

Vous devez spécifier exactement où se trouve find.exe. Sinon, Windows fourni FIND.EXE (à partir des anciennes commandes de type DOS) sera exécuté, car il se trouve probablement avant l’environnement GnuWin32 dans l’environnement PATH, avec des parameters et des résultats différents.

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

Donner en premier les fichiers les plus longs (c.-à-d. Peut-être que ces longs fichiers ont besoin d’être modifiés?), Et exclure certains répertoires de fournisseurs:

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

Pour Windows , l’outil facile et rapide est LocMesortingcs .

Sur OS X au moins, les commandes find + xarg + wc listées dans certaines des autres réponses impriment “total” plusieurs fois sur de grandes listes, et il n’y a pas de total complet donné. J’ai pu obtenir un seul total 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; }'

tandis que j’aime les scripts, je préfère celui-ci car il montre également un résumé par fichier aussi longtemps qu’un total

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

Si vous voulez restr simple, supprimez l’intermédiaire et appelez simplement wc avec 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 supportent des lignes de commandes très longues). Votre projet contient 74 fichiers, vous avez donc tout le loisir de vous développer.

très simplement

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

J’ai un boîtier occupé installé sur mon système Windows. Alors voici ce que j’ai fait.

 ECHO OFF for /r %%G in (*.php) do ( busybox grep . "%%G" | busybox wc -l ) 

J’ai utilisé ce script en ligne que je lance depuis le répertoire de 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 

Cela produit cette sortie:

 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.