recuento (no en blanco) líneas de código en bash

Question

En Bash, ¿cómo puedo contar el número de líneas de código no en blanco en un proyecto?

Answer 1

cat foo.c | sed '/^\s*$/d' | wc -l 

Y si se tiene en cuenta las líneas de comentarios en blanco:

cat foo.pl | sed '/^\s*#/d;/^\s*$/d' | wc -l 

Aunque, eso es depende del idioma.

Answer 2

awk '/^[[:space:]]*$/ {++x} END {print x}' "$testfile" 

Answer 3

w _ cuenta líneas, palabras, caracteres, de modo de contar todas las líneas (incluyendo los en blanco) usan:

wc *.py 

para filtrar las líneas en blanco, se puede utilizar grep:

grep -v '^\s*$' *.py | wc 

'-v' le dice a grep para dar salida a todas las líneas excepto los que coinciden '^' es el comienzo de una línea '\ s *' es cero o más espacios en blanco '$' es el final de una línea * .py es mi ejemplo para todo el archivo s desea contar (todos los archivos python en el directorio actual) salida de tubería a wc. Listo.

Estoy respondiendo mi propia (genuina) pregunta. No se pudo encontrar una entrada de stackoverflow que cubriera esto.

Answer 4

Si desea utilizar algo más que un script de shell, trate CLOC:

recuentos cloc líneas en blanco, comentar líneas y líneas físicas de código fuente en muchos lenguajes de programación. Se está escrito completamente en Perl sin dependencias fuera de la distribución estándar de de Perl v5.6 y superior (código de algunos módulos externos es incrustado dentro cloc) y así es bastante portátil.

Answer 5

Hay muchas maneras de hacerlo, utilizando utilidades de shell comunes.

Mi solución es:

grep -cve '^\s*$' <file> 

Esta expresión busca líneas en <archivo> la no coinciden (-v) líneas que coinciden con el patrón (-e) '^ \ s * $', que es el comienzo de una línea, seguido de 0 o más caracteres en blanco, seguido del final de una línea (es decir, sin contenido distinto del espacio en blanco), y muestra un recuento de líneas coincidentes (-c) en lugar de las líneas correspondientes.

Una ventaja de este método sobre los métodos que implican la tubería en el wc, es que se pueden especificar varios archivos y obtener una cuenta separada para cada archivo:

$ grep -cve '^\s*$' *.hh 

config.hh:36 
exceptions.hh:48 
layer.hh:52 
main.hh:39 

Answer 6

cat 'filename' | grep '[^ ]' | wc -l 

debe hacer el truco muy bien

Answer 7

Depende de la cantidad de archivos que tenga en el proyecto.En teoría, puede usar

grep -c '.' <list of files> 

Donde puede completar la lista de archivos utilizando la utilidad de búsqueda.

grep -c '.' `find -type f` 

Le daría un recuento de líneas por archivo.

Answer 8

#!/bin/bash 
find . -path './pma' -prune -o -path './blog' -prune -o -path './punbb' -prune -o -path './js/3rdparty' -prune -o -print | egrep '\.php|\.as|\.sql|\.css|\.js' | grep -v '\.svn' | xargs cat | sed '/^\s*$/d' | wc -l 

Lo anterior le dará el número total de líneas de código (líneas en blanco eliminados) para un proyecto (carpeta actual y todas las subcarpetas de forma recursiva).

En el anterior "./blog" "./punbb" "./js/3rdparty" y "./pma" son carpetas que incluyo en la lista negra porque no escribí el código en ellas. También .php, .as, .sql, .css, .js son las extensiones de los archivos que se están mirando. Cualquier archivo con una extensión diferente es ignorado.

Answer 9

grep -v '^\W*$' `find -type f` | grep -c '.' > /path/to/lineCountFile.txt 

da un conteo agregado para todos los archivos en el directorio actual y sus subdirectorios.

HTH!

Answer 10

Esto le da al recuento del número de líneas sin contar las líneas en blanco:

grep -v ^$ filename wc -l | sed -e 's/ //g' 

Answer 11

escritura para contar de forma recursiva todas las líneas no están en blanco con una determinada extensión de archivo en el directorio actual:

#!/usr/bin/env bash 
(
echo 0; 
for ext in "$@"; do 
    for i in $(find . -name "*$ext"); do 
     sed '/^\s*$/d' $i | wc -l ## skip blank lines 
     #cat $i | wc -l; ## count all lines 
     echo +; 
    done 
done 
echo p q; 
) | dc; 

el uso de la muestra:

./countlines.sh .py .java .html 

Answer 12

Si desea que la suma de todas las líneas no están en blanco para todos los archivos o f una extensión de archivo dada a lo largo de un proyecto:

while read line 
do grep -cve '^\s*$' "$line" 
done < <(find $1 -name "*.$2" -print) | awk '{s+=$1} END {print s}' 

Primero arg es el directorio base del proyecto, el segundo es la extensión del archivo. Uso de la muestra:

./scriptname ~/Dropbox/project/src java 

Es poco más que una colección de soluciones anteriores.

Answer 13

Ya hay un programa para esto en Linux llamado 'wc'.

Sólo

wc -l *.c 

y le da el total de líneas y las líneas para cada archivo.

Answer 14

grep -cvE '(^\s*[/*])|(^\s*$)' foo 

-c = count 
-v = exclude 
-E = extended regex 
'(comment lines) OR (empty lines)' 
where 
^ = beginning of the line 
\s = whitespace 
* = any number of previous characters or none 
[/*] = either/or * 
| = OR 
$ = end of the line 

publico esto porque otras opciones me dieron respuestas incorrectas. Esto funcionó con mi fuente de Java, donde las líneas de comentarios comienzan con/o * (uso * en cada línea en el comentario de varias líneas).

Answer 15

Aquí hay un script Bash que cuenta las líneas de código en un proyecto. Atraviesa un árbol fuente recursivamente y excluye las líneas en blanco y los comentarios de una sola línea que usan "//".

# $excluded is a regex for paths to exclude from line counting 
excluded="spec\|node_modules\|README\|lib\|docs\|csv\|XLS\|json\|png" 

countLines(){ 
    # $total is the total lines of code counted 
    total=0 
    # -mindepth exclues the current directory (".") 
    for file in `find . -mindepth 1 -name "*.*" |grep -v "$excluded"`; do 
    # First sed: only count lines of code that are not commented with // 
    # Second sed: don't count blank lines 
    # $numLines is the lines of code 
    numLines=`cat $file | sed '/\/\//d' | sed '/^\s*$/d' | wc -l` 

    # To exclude only blank lines and count comment lines, uncomment this: 
    #numLines=`cat $file | sed '/^\s*$/d' | wc -l` 

    total=$(($total + $numLines)) 
    echo " " $numLines $file 
    done 
    echo " " $total in total 
} 

echo Source code files: 
countLines 
echo Unit tests: 
cd spec 
countLines 

Esto es lo que la salida se parece a my project:

Source code files: 
    2 ./buildDocs.sh 
    24 ./countLines.sh 
    15 ./css/dashboard.css 
    53 ./data/un_population/provenance/preprocess.js 
    19 ./index.html 
    5 ./server/server.js 
    2 ./server/startServer.sh 
    24 ./SpecRunner.html 
    34 ./src/computeLayout.js 
    60 ./src/configDiff.js 
    18 ./src/dashboardMirror.js 
    37 ./src/dashboardScaffold.js 
    14 ./src/data.js 
    68 ./src/dummyVis.js 
    27 ./src/layout.js 
    28 ./src/links.js 
    5 ./src/main.js 
    52 ./src/processActions.js 
    86 ./src/timeline.js 
    73 ./src/udc.js 
    18 ./src/wire.js 
    664 in total 
Unit tests: 
    230 ./ComputeLayoutSpec.js 
    134 ./ConfigDiffSpec.js 
    134 ./ProcessActionsSpec.js 
    84 ./UDCSpec.js 
    149 ./WireSpec.js 
    731 in total 

disfrutar! - Curran

Answer 16

Este comando cuenta el número de líneas no en blanco en nuestro proyecto.
cat fileName | grep -v ^$ | wc -l
grep -v^$ función de expresión regular es ignorar líneas en blanco.

Answer 17

rgrep . | wc -l 

indica el recuento de las líneas que no están en blanco en el directorio de trabajo actual.