bash - sous - compter nombre fichier repertoire unix




Comment compter récursivement toutes les lignes de code dans un répertoire? (20)

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


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 le nouveau code de ligne, cela ne sera pas compté!

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


É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 trouve pour tous les fichiers ( -type f ). Pour trouver par extension de fichier, utilisez -name :

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

En supposant que personne ne verra jamais cela enterré à l'arrière ... Pourtant, aucune des réponses à ce jour n'aborde le problème des noms de fichiers avec des espaces. De plus, tous ceux qui utilisent xargs d'échouer si la longueur totale des chemins dans l'arborescence dépasse la limite de taille de l'environnement du shell (par défaut, elle est de quelques mégaoctets sous Linux). En voici un qui résout ces problèmes d'une manière plutôt directe. Le sous-shell prend soin des fichiers avec des espaces. L' awk totalise le flux des sorties individuelles de fichiers wc , donc ne devrait jamais manquer d'espace. Il limite également l' exec aux fichiers uniquement (en ignorant les répertoires):

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

Encore une autre commande pour obtenir la somme de tous les fichiers (Linux bien sûr)

find ./ -type f -exec wc -l {}  \; | cut -d' ' -f1 | paste -sd+ | bc

Différence principale par rapport aux autres réponses:

  1. en utilisant find -exec ,
  2. en utilisant la pâte (avec la coupe) ,
  3. en utilisant bc

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


J'ai occupé la boîte installée sur mon système de fenêtres. Alors voici ce que j'ai fait.

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

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

Sebastian Bergmann a écrit un outil appelé PHPLOC qui fait ce que vous voulez et qui 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 indiquer à quel point un projet est complexe avant de commencer à travailler dessus.


POSIX

Lignes dans chaque fichier:

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

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

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

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

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

Pour Windows , l'outil facile et rapide est LocMetrics .


Pour un autre one-liner:

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

travaille sur des noms avec des espaces, ne sort qu'un seul nombre.


Si vous n'avez besoin que du nombre total de lignes, disons 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 où exactement est le find.exe sinon le Windows fourni FIND.EXE (à partir des anciennes commandes de type DOS) sera exécuté, car il est probablement avant le GnuWin32 dans l'environnement PATH, 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.


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, 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 le rendre permanent, ajoutez-le à l'un des fichiers d'initialisation ( ~/.bashrc , ~/.bash_profile etc.).


Sur OS X au moins, les commandes find + xarg + wc listées dans d'autres réponses impriment plusieurs fois "total" sur les grandes listes, et il n'y a pas de total complet donné. J'ai réussi à 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; }'


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

J'ai couru dans 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
-------------------------------------------------------------------------------

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


ce que vous voulez est un simple pour la boucle:

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

pour les sources seulement:

wc `find`

pour filtrer, il suffit d'utiliser grep

wc `find | grep .php$`

très simplement

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

Essayer:

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

L'outil SLOCCount peut également vous aider.

Cela donnera des lignes de code de source précises pour n'importe quelle hiérarchie, ainsi que des statistiques supplémentaires.





shell