¿Cómo puedo 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 determinado, pero ignora los subdirectorios. Estaba pensando que esto podría funcionar, pero regresa 74, que definitivamente no es el caso ...

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

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

preguntado el 31 de agosto de 09 a las 14:08

30 Respuestas

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 apunte, así como algunas estadísticas adicionales.

Salida ordenada:

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

Respondido el 20 de junio de 20 a las 10:06

cloc.sourceforge.net podría valer la pena buscarlo como una alternativa al sloccount (más idiomas pero menos información) - Aster

con incluir archivos también: find . -name '*.php' -o -name '*.inc' | xargs wc -l - Rymo

Esto imprimirá más de un número cuando haya muchos archivos (porque wc se ejecutará varias veces. Tampoco maneja muchos nombres de archivos especiales. - l0b0

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

Si un nombre de directorio contiene espacios ... ¡¡el comando anterior falla !! - nitish712

Para otro one-liner:

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

Funciona con nombres con espacios y solo genera un número.

Respondido 27 ago 20, 23:08

+1 ídem ... buscado para siempre ... todos los demás comandos "buscar" solo devolvieron el número de archivos reales ... ¡¡¡las cosas -print0 aquí obtuvieron el recuento de líneas real para mí !!! ¡Gracias! - Ronedog

@ TorbenGundtofte-Bruun - ver man find .. print0 con xargs -0 te permite operar en archivos que tienen espacios u otros caracteres extraños en su nombre - Shizzmo

@ TorbenGundtofte-Bruun - también, el -0 en xargs corresponde al print0, es una especie de codificación / decodificación para manejar los espacios. - Tristán Reid

Si necesita más de un filtro de nombre, he descubierto que (al menos con la versión MSYSGit de find), necesita parens adicionales: ( find . \( -name '*.h' -o -name '*.cpp' \) -print0 | xargs -0 cat ) | wc -l - Zrax

@DesignbyAdrian: llevar un diario ayuda con la recuperación de fallos, no la velocidad. Es probable que esté obteniendo un buen rendimiento debido al almacenamiento en caché o un disco duro muy rápido. - jmh

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

wc -l **/*.php

En el caparazón Bash, esto requiere globstar opción a configurar, de lo contrario, la ** glob-operator 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_profile etc.).

Respondido 20 ago 13, 07:08

Estoy votando esto por simplicidad, sin embargo, solo quiero señalar que no parece buscar los directorios de forma recursiva, solo verifica los subdirectorios del directorio actual. Esto está en SL6.3. - Vidente Godric

Eso depende de su caparazón y de las opciones que haya configurado. Bash requiere globstar para ser establecido para que esto funcione. - miguel salvaje

@PeterSenna, con el archivo actual del kernel 3.9.8, el comando wc -l **/*.[ch] encuentra un total de 15195373 líneas. No estoy seguro de si lo considera un "valor muy bajo". Nuevamente, debe asegurarse de tener globstar habilitado en Bash. Puedes consultar con shopt globstar. Para habilitarlo explícitamente, haga shopt -s globstar. - miguel salvaje

@MichaelWild Esta es una buena solución, pero aún se desbordará ARG_MAX si tiene una gran cantidad de .php archivos, ya que wc no está incorporado. - Reincorporar a Monica por favor

@AlbertSamuel No, necesitaría comparar la lista de archivos producidos por ambos métodos. Mi método tiene el problema de no funcionar para una gran cantidad de archivos, como lo menciona @BroSlow. La respuesta aceptada fallará si las rutas producidas por find contener espacios. Eso podría arreglarse usando print0 y --null con el find y xargs llamadas, respectivamente. - miguel salvaje

Puede utilizar el cloc utilidad que se construye para este propósito exacto. Informa cada uno la cantidad de líneas en cada idioma, junto con cuántas de ellas 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
-------------------------------------------------------------------------------

Respondido 27 ago 20, 23:08

Esa es una herramienta encantadora que funciona bien y rápidamente brinda estadísticas útiles al final. Me encanta. - robar forrest

Tenga en cuenta que puede ejecutar comandos Unix en Windows usando cygwin (u otros puertos / entornos similares). Para mí, tener este tipo de acceso tan extremadamente útil, es una necesidad. Una línea de comandos de Unix es mágica. Me gustan especialmente las expresiones regulares y perl. - Curtis Yallop

CLOC y SLOCCount funcionan bien en macbook de mediados de 2015. Tenga en cuenta que sus números son cercanos pero no exactamente iguales para el proyecto de Android Java 127k. También tenga en cuenta que el equivalente de iOS tenía el doble de LoC; por lo tanto, la métrica de "costo" en SLOCCount podría estar desactivada (o tal vez los desarrolladores de iOS hacen el doble de lo que hacen los desarrolladores de Android. :-) - Max Weber

¿Consideraría editar el comienzo de esta pregunta para dejar en claro que cloc es multiplataforma ya que es solo un script de Perl? - hebra kyle

Simplemente perfecto, también funciona bien en Windows bash, por supuesto. - yurisnm

En sistemas similares a Unix, existe una herramienta llamada cloc que 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
-------------------------------------------------------------------------------

Respondido 28 ago 20, 01:08

@moose técnicamente simtao lo mencionó específicamente como una solución para usuarios de Windows, sin mencionar linux o unix en absoluto. - tim seguine

@moose Table fue editado en su respuesta mucho más tarde que mi respuesta, ahora los dos se ven similares. - Calmarius

Me gusta. cloc es realmente genial. Pero, ¿qué significa ese nombre? - Manoel Vilela

¡Ahora también está en Windows! Asumiendo que tienes chocolateoso: choco install cloc - icc97

@ManoelVilela Cuenta Líneas De Código - busterroni

No especificó cuántos archivos hay o cuál es la salida deseada.

Esto puede ser lo que estás buscando:

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

Respondido 27 ago 20, 23:08

Esto funcionará, siempre que no haya demasiados archivos: si hay muchos archivos, obtendrá varias líneas como resultado (xargs dividirá la lista de archivos en varias sublistas). Pascal MARTÍN

Ah, sí. Por eso dije que no especificó cuántos archivos hay. Mi versión es más fácil de recordar, pero la versión de Shin es mejor si tiene más de unos pocos archivos. Lo estoy votando. - Paweł Polewicz

Necesitaba adaptar esto para usarlo en una función, donde las comillas simples son demasiado restrictivas: 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/* . } Los resultados estuvieron cerca del recuento de *.py, pero no sabia *.js, *.html. - jalanb

Otra variación más :)

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

Esto dará la suma total, en lugar de archivo por archivo.

Añada . después de find para que funcione.

Respondido 27 ago 20, 23:08

ambas respuestas suman las líneas. - jose123a123

Al menos en cygwin, obtuve mejores resultados con: $ find -name \*\.php -print0 | xargs -0 cat | wc -l - Martín Haeberli

en Darwin, esto solo da un gran total: find . -name '*.php' | xargs cat | wc -l ... mientras que esto da archivo por archivo y un gran total: find . -name '*.php' | xargs wc -l - OsamaBinIniciar sesión

Utilice las encontrar's -exec y awk. Aquí vamos:

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

Este fragmento busca 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; }'

Respondido 28 ago 20, 00:08

Funcionalmente, esto funciona perfectamente, pero en listas grandes (fuente de Linux) es realmente lento porque está iniciando un proceso wc para cada archivo en lugar de 1 proceso wc para todos los archivos. Lo cronometré en 31 segundos usando este método en comparación con 1.5 segundos usando find . -name '*.c' -print0 |xargs -0 wc -l. Dicho esto, este método más rápido (al menos en OS X), termina imprimiendo "total" varias veces, por lo que se requiere un filtrado adicional para obtener un total adecuado (publiqué detalles en mi respuesta). - doug richardson

Esto tiene la ventaja de trabajar para un número ilimitado de archivos. ¡Bien hecho! - ekscrypto

esta es una solución mucho mejor una vez que se trabaja con una gran cantidad de GB y archivos. haciendo uno wc en una forma de cat es lento porque el sistema primero debe procesar todos los GB para comenzar a contar las líneas (probado con 200 GB de jsons, archivos de 12k). haciendo wc primero, luego contar el resultado es mucho más rápido - al aire libre

@DougRichardson, podría considerar esto en su lugar: find . -type f -exec wc -l {} \+ or find . -name '*.py' -type f -exec wc -l {} \+ que imprime un total al final de la salida. Si todo lo que le interesa es el total, entonces podría ir un poco más lejos y usar tail: find . -type f -exec wc -l {} \+ | tail -1 or find . -name '*.py' -type f -exec wc -l {} \+ | tail -1 - jamie jag

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

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

Respondido 27 ago 20, 23:08

esto no hace exactamente lo que piensas. encontrar . -nombre '. [am] 'es idéntico a encontrar. -nombre '. [a | m] 'ambos encontrarán todos los archivos que terminen con .m o .a - Omry Yadan

pero el segundo también encontrará archivos que terminen en. | , Si alguna. Entonces [h | c | cpp | php | cc] termina siendo lo mismo que [hcp |]. - OsamaBinIniciar sesión

las comillas inversas están en desuso, prefiera $() - Sandburg

Esto funciona con Cygwin. Por supuesto, la unidad "C: \" tiene que seguir la convención cygwin, como por ejemplo: wc $ (find / cygdrive / c // SomeWindowsFolderj / -type f | egrep "\. (H | c | cpp | php | cc) ") - Christian Gingras

POSIX

A diferencia de la mayoría de las otras respuestas aquí, estas funcionan en cualquier sistema POSIX, para cualquier cantidad 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 ruta de 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, descendente

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

Total de líneas en todos los archivos

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

Respondido 07 Oct 18, 03:10

Hay una pequeña herramienta llamada slocuenta para contar las líneas de código en un 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.

Respondido 27 ago 20, 23:08

Para ventanas, LocMetrics Hacer el trabajo - Camille

Una repetición de la respuesta aceptada (aunque publicada al mismo tiempo). - Pedro Mortensen

Quieres un simple for bucle:

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

Respondido 27 ago 20, 23:08

¿No es esto una exageración en comparación con las respuestas que sugieren xargs? - nathan fellman

No, Nathan. Las respuestas xargs no necesariamente imprimirán el recuento como un solo número. Puede que solo imprima un montón de subtotales. - robar kennedy

¿Qué hará este programa si los nombres de los archivos contienen espacios? ¿Qué pasa con las nuevas líneas? ;-) - Paweł Polewicz

Si los nombres de sus archivos contienen nuevas líneas, diría que tiene problemas mayores. - Kzqai

@ennuikiller Número de problemas con esto, en primer lugar se romperá en archivos con espacios en blanco. Configuración IFS=$'\n' antes de que el bucle lo arreglara al menos para todos los archivos excepto para los archivos con nuevas líneas en sus nombres. En segundo lugar, no estás citando '*.php', por lo que se expandirá por el shell y no find, y ergo en realidad no encontrará ninguno de los archivos php en subdirectorios. También el -print es redundante, ya que está implícito en ausencia de otras acciones. - Reincorporar a Monica por favor

Solo para fuentes:

wc `find`

Para filtrar, solo use grep:

wc `find | grep .php$`

Respondido 27 ago 20, 23:08

La herramienta Tokei muestra estadísticas sobre el código en un directorio. Tokei mostrará el número 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.

Respondido 28 ago 20, 01:08

Uno sencillo que será rápido, utilizará todo el poder de búsqueda / filtrado de find, no falla cuando hay demasiados archivos (desbordamiento de argumentos numéricos), funciona bien con archivos con símbolos divertidos en su nombre, sin usar xargs, y no lanzará una cantidad inútilmente alta de comandos externos (gracias a + por find's -exec). Aqui tienes:

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

Respondido 28 ago 20, 00:08

Estaba a punto de publicar una variante de esto yo mismo (con \; en lugar de + como no lo sabía), esta respuesta debería ser la respuesta correcta. - marca k cowan

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

Sebastian Bergmann escribió una herramienta llamada PHPLOC que hace lo que quiere y, además, le proporciona una descripció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, porque puede decirle aproximadamente qué tan complejo es un proyecto antes de comenzar a trabajar con él.

Respondido 31 Oct 13, 23:10

Ninguna de las respuestas hasta ahora aborda el problema de los nombres de archivo con espacios.

Además, todo ese uso xargs están sujetos a fallar si la longitud total de las rutas en el árbol excede el límite de 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 subcapa se encarga de los archivos con espacios. La awk totaliza el flujo de un archivo individual wc salidas, por lo que nunca debería quedarse sin espacio. También restringe la exec solo a archivos (omitiendo directorios):

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

Respondido 28 ago 20, 01:08

WC -L? mejor use GREP -C ^

wc -l? Wrong!

Los programas wc comando cuenta códigos de nuevas líneas, no ¡líneas! Cuando la última línea del archivo no termina con un nuevo código de línea, ¡esto no se 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 of '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, cuidado con el wc -l trampa (cuenta entra, no líneas !!!)

Respondido 28 ago 20, 00:08

Por favor lea el Definición POSIX de una línea. Con grep -c ^ estás contando el número de lineas incompletas, y tales líneas incompletas no pueden aparecer en un Archivo de texto. - gniourf_gniourf

Lo sé. En la práctica, solo la última línea puede estar incompleta porque no tiene EOL. La idea es contar todas las líneas, incluida una incompleta. Es un error muy frecuente, contando solo líneas completas. después de contar estamos pensando "¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿?? ??? Esta es la respuesta por qué y la receta de cómo hacerlo correctamente. - Znik

O, si quieres un delineador: find -type f -name '*.php' -print0 | xargs -0 grep -ch ^ | paste -sd+ - | bc Vea aquí alternativas a bc: stackoverflow.com/q/926069/2400328 - tecniao

¿A quién le importa la última línea? Especialmente teniendo en cuenta todos los lineas vacias dentro de los archivos. Es todo aproximado de todas formas. - oxidado

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

Respondido 28 ago 20, 01:08

Es bastante improbable que OP esté en Windows si están usando bash. - usuario8174234

El título de la pregunta de @VanessaMcHale y la descripción no requieren claramente una solución solo para Unix. Entonces, la solución basada en Windows es aceptable. También Google me señaló esta página cuando estaba buscando una solución similar. - Walv

Este comentario me ayudó. Probé esto y funciona bien. - alan f

Si desea que sus resultados estén ordenados por número de líneas, simplemente puede agregar | sort or | sort -r (-r para orden descendente) a la primera respuesta, así:

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

Respondido el 14 de diciembre de 12 a las 19:12

Dado que la salida de xargs wc -l es numérico, en realidad se necesitaría usar sort -n or sort -nr. - polvo ingram

Dar primero los archivos más largos (es decir, ¿tal vez estos archivos largos necesitan algo de amor de refactorización?) Y excluir algunos directorios de proveedores:

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

Respondido 08 Jul 13, 04:07

La exclusión de directorios es importante en proyectos en los que hay código generado o archivos copiados en el proceso de compilación. Alberto Vila Calvo

Muy simple:

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

Respondido 27 ago 20, 23:08

fallará si hay un espacio o una nueva línea en uno de los nombres de archivo - Paweł Polewicz

Algo diferente:

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

Esto funciona bien, pero necesita tener al menos una *.php archivo en la carpeta actual o una de sus subcarpetas, o bien wc establos.

Respondido 27 ago 20, 23:08

también puede desbordar ARG_MAX - marca k cowan

Es muy facil con Z shell (zsh) globos:

wc -l ./**/*.php

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

Respondido 28 ago 20, 01:08

Puede utilizar una utilidad llamada codel (aquí). Es un módulo de Python simple para contar líneas con formato colorido.

INSTALACIÓN

pip install codel

Uso

Para contar líneas de archivos C ++ (con .cpp y .h extensiones), utilice:

codel count -e .cpp .h

También puede ignorar algunos archivos / carpetas con el formato .gitignore:

codel count -e .py -i tests/**

Ignorará todos los archivos en el tests/ carpeta.

La salida se ve así:

Salida larga

También puede acortar la salida con el -s bandera. Ocultará la información de cada archivo y mostrará solo información sobre cada extensión. A continuación se muestra el ejemplo:

Salida corta

Respondido 28 ago 20, 01:08

¿Hay alguna forma de hacer esto para todos los archivos de texto, no solo para extensiones específicas? - aarón franco

@AaronFranke A estas alturas no hay forma. - voilálex

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

Respondido 01 Feb 19, 19:02

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 GnuWin32 instalado. Como esto:

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

Debe especificar dónde está exactamente el archivo find.exe; de ​​lo contrario, Windows proporcionó ENCONTRAR.EXE (de los antiguos comandos tipo DOS), ya que probablemente sea anterior al GnuWin32 en el entorno PATH y tenga diferentes parámetros y resultados.

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

Respondido 27 ago 20, 23:08

En el ejemplo anterior, estoy usando bash para Windows en lugar de cmd.exe, por eso hay barras diagonales "/" y no barras invertidas "\". - Neven Boyanov

Si bien me gustan los scripts, prefiero este, ya que también muestra un resumen por archivo siempre que sea un total:

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

Respondido 28 ago 20, 01:08

Re "... siempre que sea un total ...": No te refieres "... así como un total ..."? - Pedro Mortensen

No necesita todos estos comandos complicados y difíciles de recordar. Solo necesitas un Python herramienta llamada contador de linea.

Un resumen rápido

Así es como obtienes la herramienta

$ pip install line-counter

Use el line comando 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, usa 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 agregar un .gitignore-como archivo de configuración. 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

Respondido 28 ago 20, 01:08

Si estás en Linux (y supongo que lo estás), te recomiendo mi herramienta polígloto. Es dramáticamente más rápido que cualquiera sloccount or cloc y es más característico que sloccount.

Puedes invocarlo con

poly .

or

poly

por lo que es mucho más fácil de usar que un intrincado script de Bash.

Respondido 28 ago 20, 01:08

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.