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

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?

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

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.

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

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

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

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

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

É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; }'

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

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

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.

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"

pour les sources uniquement:

wc `find`

pour filtrer, utilisez simplement grep

wc `find | grep .php$`

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

Je sais que la question est étiquetée comme frapper, 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.

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

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

très simplement

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

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

Pour Windows , LocMetrics est un outil simple et rapide .

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

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.

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.

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 .

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.

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

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.

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

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

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; }'