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


1625

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?

Respuestas:


2651

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


31
cloc.sourceforge.net podría valer la pena mirar como una alternativa a sloccount (más idiomas pero menos información)
AsTeR

31
con archivos de inclusión también:find . -name '*.php' -o -name '*.inc' | xargs wc -l
rymo

52
Esto imprimirá más de un número cuando hay muchos archivos (porque wcse ejecute varias veces también no maneja muchos nombres de archivo especial..
l0b0

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

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

474

Para otra línea:

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

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


1
+1 ídem ... buscado para siempre ... todos los demás comandos "buscar" solo devolvieron el número de archivos reales ... ¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡'' ¡Gracias!
Ronedog

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

2
@ TorbenGundtofte-Bruun: además, el -0 en xargs corresponde al print0, es una especie de codificación / decodificación para manejar los espacios.
Tristan Reid

77
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

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

398

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


77
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.
Godric Seer

77
Eso depende de su shell y las opciones que haya configurado. Bash requiere globstarestar configurado para que esto funcione.
Michael Wild

2
@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 si considera que es un "valor muy bajo". Una vez más, debe asegurarse de haber globstarhabilitado en Bash. Puedes consultar con shopt globstar. Para habilitarlo explícitamente, hazlo shopt -s globstar.
Michael Wild

55
@MichaelWild Esta es una buena solución, pero aún se desbordará ARG_MAXsi tiene una gran cantidad de .phparchivos, ya wcque no está integrada.
Restablecer Monica Please

1
@AlbertSamuel No, necesitaría comparar la lista de archivos producidos por ambos métodos. Mi método tiene el problema de no funcionar para grandes cantidades de archivos, como lo menciona @BroSlow. La respuesta aceptada fallará si las rutas producidas por findcontienen espacios. Eso podría solucionarse usando print0y --nullcon las llamadas findy xargs, respectivamente.
Michael Wild

363

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

44
Esa es una herramienta encantadora que se ejecuta bien y rápidamente brinda estadísticas útiles al final. Quiéralo.
Rob Forrest

44
Tenga en cuenta que puede ejecutar comandos de Unix en Windows utilizando cygwin (u otros puertos / entornos similares). Para mí, tener este tipo de acceso tan extremadamente útil, es una necesidad. Una línea de comando unix es mágica. Especialmente me gustan 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 127k Java Android. También tenga en cuenta que el equivalente de iOS tenía 2 veces la LoC; por lo tanto, la métrica de "costo" en SLOCCount podría estar desactivada (o tal vez el desarrollador de iOS haga el doble de lo que hace el desarrollador de Android. :-)
maxweber

2
¿Consideraría editar el comienzo de esta pregunta para dejar en claro que cloces multiplataforma ya que es solo un script de Perl?
Kyle Strand

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

100

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

2
@moose técnicamente Simtao lo mencionó específicamente como una solución para usuarios de Windows, sin mencionar a Linux o Unix.
Tim Seguine

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

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

¡Ahora también está en Windows! Suponiendo que tienes chocolate :choco install cloc
icc97

35

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

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

Ah, sí. Es por eso que 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 tienes más de unos pocos archivos. Lo estoy votando.
Paweł Polewicz

Que necesitaba adaptarse para su uso en esta función, donde las comillas simples son demasiado restrictivos: 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 fueron cerca de slocount *.py, pero no lo sabía *.js, *.html.
jalanb

31

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


ambas respuestas suman las líneas.
josh123a123

Al menos en Cygwin, tuve mejores resultados con:$ find -name \*\.php -print0 | xargs -0 cat | wc -l
Martin 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
OsamaBinLogin

30

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

2
Funcionalmente, esto funciona perfectamente, pero en una lista grande (fuente de Linux) es realmente lento porque está iniciando un proceso de wc para cada archivo en lugar de un proceso de wc para todos los archivos. Lo cronometré a 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

1
Esta es una solución mucho mejor una vez que se trabaja con gran cantidad de GB y archivos. hacer uno wcen forma de a cates 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). hacer wcprimero y luego contar el resultado es mucho más rápido
ulkas

1
@DougRichardson, podría considerar esto en su lugar: find . -type f -exec wc -l {} \+o 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 -1ofind . -name '*.py' -type f -exec wc -l {} \+ | tail -1
JamieJag

25

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.


66
esto no hace exactamente lo que piensas. encontrar . -name ' . [am]' es idéntico a find. -name ' . [a | m]' ambos encontrarán todos los archivos que
terminen en

1
pero el segundo también encontrará archivos que terminan en. , Si alguna. Entonces [h | c | cpp | php | cc] termina siendo lo mismo que [hcp |].
OsamaBinLogin

los backticks están en desuso, prefiero$()
Sandburg

Esto funciona bajo 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

21

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

19

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.


Para Windows, LocMetrics hace el trabajo
Camille

15

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"

3
¿No es esto excesivo en comparación con las respuestas que sugieren xargs?
Nathan Fellman el

55
No Nathan Las respuestas xargs no necesariamente imprimirán el recuento como un solo número. Es posible que solo imprima un montón de subtotales.
Rob Kennedy el

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

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

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

12

solo para fuentes:

wc `find`

para filtrar, solo use grep

wc `find | grep .php$`

11

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

2
Estaba a punto de publicar una variante de esto yo mismo (en \;lugar de +como no lo sabía), esta respuesta debería ser la respuesta correcta.
Mark K Cowan

7

Sé que la pregunta está etiquetada como , 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.


7

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

6

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


Lea la definición POSIX de una línea . Con grep -c ^usted está contando el número de líneas incompletas , y tales líneas incompletas no pueden aparecer en un archivo de texto .
gniourf_gniourf

2
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 "¿por qué me perdí la última línea?" Esta es la respuesta por qué, y la receta de cómo hacerlo correctamente.
Znik

O, si desea un revestimiento único: find -type f -name '*.php' -print0 | xargs -0 grep -ch ^ | paste -sd+ - | bc consulte aquí las alternativas a bc: stackoverflow.com/q/926069/2400328
techniao

4

muy simple

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

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

4

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

1
Como la salida de xargs wc -les numérica, uno realmente necesitaría usar sort -no sort -nr.
Dustin Ingram

4

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


Es poco probable que OP esté en Windows si están usando bash.

1
El título y la descripción de la pregunta de @VanessaMcHale no requieren claramente una solución exclusiva de Unix. Por lo tanto, 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ó. Intenté esto y funciona bien.
Allan F

4

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


también puede desbordarse ARG_MAX
Mark K Cowan

4

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.


4

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.


4

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 .


1
Esta debería ser la respuesta aceptada
Elijas

3

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.


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

3

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

3

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.


¡Me gusta este! Si está en un entorno híbrido C / C ++:wc -l `find . -type f \( -name "*.cpp" -o -name "*.c" -o -name "*.h" \) -print`
Bram

me sorprendió que no fuera la respuesta principal
ms4720

3

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


3

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

2

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

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.