¿Cómo contar todas las líneas de código en un directorio de forma recursiva?

Tenemos una aplicación PHP y queremos contar todas las líneas de código en un directorio específico y sus subdirectorios. No necesitamos ignorar los comentarios, ya que solo estamos tratando de tener una idea aproximada.

wc -l *.php 

Ese comando funciona muy bien dentro de un directorio dado, pero ignora los subdirectorios. Estaba pensando que esto podría funcionar, pero está devolviendo 74, que definitivamente no es el caso ...

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

¿Cuál es la sintaxis correcta para alimentar en todos los archivos?

Tratar:

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

La herramienta SLOCCount también puede ayudar.

Le dará un recuento preciso de líneas de código fuente para cualquier jerarquía a la que lo señale, así como algunas estadísticas adicionales.

Salida ordenada:

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

Para otra línea:

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

funciona en nombres con espacios, solo genera un número.

Si usa una versión decentemente reciente de Bash (o ZSH), es mucho más simple:

wc -l **/*.php

En el shell Bash, esto requiere globstarque se establezca la opción, de lo contrario, el **operador glob no es recursivo. Para habilitar esta configuración, emita

shopt -s globstar

Para hacer esto permanente, agréguelo a uno de los archivos de inicialización ( ~/.bashrc, ~/.bash_profileetc.).

Puede usar la clocutilidad que está construida para este propósito exacto. Informa a cada uno la cantidad de líneas en cada idioma, junto con cuántos de ellos son comentarios, etc. CLOC está disponible en Linux, Mac y Windows.

Ejemplo de uso y salida:

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

En sistemas similares a UNIX, existe una herramienta llamada clocque proporciona estadísticas de código.

Me encontré con un directorio aleatorio en nuestra base de código que dice:

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

No especificó cuántos archivos hay o cuál es la salida deseada. Es esto lo que estás buscando:

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

Otra variación más :)

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

Editar: esto le dará la suma total, en lugar de archivo por archivo.

Edit2: Agregar .después findpara que funcione

Sorprendentemente no hay respuesta basada en hallazgos -execy awk. Aquí vamos:

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

Este fragmento se encuentra para todos los archivos ( -type f). Para buscar por extensión de archivo, use -name:

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

Más común y simple para mí, supongamos que necesita contar archivos de diferentes extensiones de nombre (digamos, también nativos)

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

Gracias por los comentarios, lo he corregido.

POSIX

A diferencia de la mayoría de las otras respuestas aquí, estas funcionan en cualquier sistema POSIX, para cualquier número de archivos y con cualquier nombre de archivo (excepto donde se indique).

Líneas en cada archivo:

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

Líneas en cada archivo, ordenadas por la ruta del archivo

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

Líneas en cada archivo, ordenadas por número de líneas, descendiendo

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

Líneas totales en todos los archivos

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

Hay una pequeña herramienta llamada sloccount para contar las líneas de código en el directorio. Cabe señalar que hace más de lo que desea, ya que ignora las líneas / comentarios vacíos, agrupa los resultados por lenguaje de programación y calcula algunas estadísticas.

Lo que quieres es un forbucle simple :

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

solo para fuentes:

wc `find`

para filtrar, solo use grep

wc `find | grep .php$`

Una sencilla que será rápida, usará todo el poder de búsqueda / filtrado de find, no fallará cuando haya demasiados archivos (desbordamiento de argumentos numéricos), funcionará bien con archivos con símbolos divertidos en su nombre, sin usar xargs, no lanzará un inútilmente alto número de comandos externos (gracias a +for find's -exec). Aqui tienes:

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

Sé que la pregunta está etiquetada como golpetazo, pero parece que el problema que está tratando de resolver también está relacionado con PHP.

Sebastian Bergmann escribió una herramienta llamada PHPLOC que hace lo que quiere y además le brinda una visión general de la complejidad de un proyecto. Este es un ejemplo de su informe:

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

Como puede ver, la información proporcionada es mucho más útil desde la perspectiva de un desarrollador, ya que puede decirle aproximadamente cuán complejo es un proyecto antes de comenzar a trabajar con él.

Adivinando que nadie verá esto enterrado en la parte posterior ... Sin embargo, ninguna de las respuestas hasta ahora llega al problema de los nombres de archivos con espacios. Además, todos los usos xargsestán sujetos a fallas si la longitud total de las rutas en el árbol excede el límite del tamaño del entorno de shell (el valor predeterminado es unos pocos megabytes en Linux). Aquí hay uno que soluciona estos problemas de una manera bastante directa. La subshell se encarga de los archivos con espacios. El awktotal del flujo de wcsalidas de archivos individuales , por lo que nunca debe quedarse sin espacio. También restringe los execarchivos solamente (omitiendo directorios):

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

WC -L? mejor uso GREP -C ^

wc -l? ¡Incorrecto! ¡El comando wc cuenta nuevos códigos de líneas, no líneas! Cuando la última línea del archivo no termina con un nuevo código de línea, ¡ esto no contará!

si aún desea contar líneas, use grep -c ^ , ejemplo completo:

#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

finalmente, ten cuidado con la trampa wc -l (¡¡¡las cuentas entran, no las líneas !!!)

muy simple

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

Si desea que sus resultados se ordenen por número de líneas, puede agregar | sorto | sort -r( -ren orden descendente) a la primera respuesta, de la siguiente manera:

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

Para Windows , la herramienta fácil y rápida es LocMetrics .

Algo diferente:

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

Esto funciona bien, pero debe tener al menos un *.phparchivo en la carpeta actual o una de sus subcarpetas, o de lo contrario se wcdetiene

Si estás en Linux (y supongo que sí), recomiendo mi herramienta políglota . Es mucho más rápido que cualquiera de los dos sloccounto clocy tiene más posibilidades que sloccount.

Puedes invocarlo con

poly .

o

poly

así que es mucho más fácil de usar que un script bash complicado.

Es muy fácil con zsh globs:

wc -l ./**/*.php

Si está utilizando bash, solo necesita actualizar. No hay absolutamente ninguna razón para usar bash.

La herramienta Tokei muestra estadísticas sobre el código en un directorio. Tokei mostrará la cantidad de archivos, líneas totales dentro de esos archivos y código, comentarios y espacios en blanco agrupados por idioma. Tokei también está disponible en Mac, Linux y Windows.

Un ejemplo de la salida de Tokei es el siguiente:

$ 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 se puede instalar siguiendo las instrucciones en el archivo README en el repositorio .

Si necesita solo el número total de líneas en, digamos sus archivos PHP, puede usar un comando de una línea muy simple incluso en Windows si tiene instalado GnuWin32. Me gusta esto:

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

Debe especificar dónde está exactamente el find.exe; de ​​lo contrario, se ejecutará FIND.EXE proporcionado por Windows (de los antiguos comandos similares a DOS), ya que probablemente sea anterior al GnuWin32 en la RUTA del entorno y tenga diferentes parámetros y resultados.

Tenga en cuenta que en el comando anterior debe usar comillas inversas, no comillas simples.

Dar primero los archivos más largos (es decir, ¿tal vez estos archivos largos necesitan un poco de amor refactorizante?) Y excluir algunos directorios de proveedores:

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

Si quiere que sea simple, elimine al intermediario y simplemente llame wccon todos los nombres de archivo:

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

O en la sintaxis moderna:

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

Funciona siempre que no haya espacios en ninguno de los nombres de directorio o nombres de archivo. Y siempre que no tenga decenas de miles de archivos (los shells modernos admiten líneas de comando realmente largas). Su proyecto tiene 74 archivos, por lo que tiene mucho espacio para crecer.

No necesita todos estos comandos complicados y difíciles de recordar. Solo necesitas una herramienta llamada line-counter .

Un resumen rápido

Así es como obtienes la herramienta

$ pip install line-counter

Use el linecomando para obtener el recuento de archivos y el recuento de líneas en el directorio actual (recursivamente)

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

Si quieres más detalles, solo úsalo 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

Y la mejor parte de esta herramienta es que puede agregarle .gitignoreun archivo de configuración similar. Puede configurar reglas para seleccionar o ignorar qué tipo de archivos contar al igual que lo que hace en '.gitignore'.

Más descripción y uso está aquí: https://github.com/MorganZhang100/line-counter

Si los archivos son demasiados, es mejor buscar el recuento total de líneas.

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

Al menos en OS X, los comandos find + xarg + wc enumerados en algunas de las otras respuestas imprimen "total" varias veces en listados grandes, y no se da un total completo. Pude obtener un total único para archivos .c usando el siguiente comando:

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