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

En Bash, ¿cómo cuento el número de líneas de código que no están en blanco en un proyecto?

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

Y si considera comentarios líneas en blanco:

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

Aunque, eso depende del idioma.

#!/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 recuento total de líneas de código (líneas en blanco eliminadas) para un proyecto (carpeta actual y todas las subcarpetas de forma recursiva).

En el "./blog" "./punbb" "./js/3rdparty" y "./pma" anteriores están las carpetas que incluí en la lista negra ya que 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 se ignora.

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

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

Hay muchas maneras de hacer esto, utilizando utilidades de shell comunes.

Mi solución es:

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

Esto busca líneas en <archivo> las líneas que no coinciden (-v) que coinciden con el patrón (-e) '^ \ s * $', que es el comienzo de una línea, seguido de 0 o más espacios en blanco, seguidos al final de una línea (es decir, sin contenido que no sea el espacio en blanco) y muestre un recuento de líneas coincidentes (-c) en lugar de las líneas coincidentes.

Una ventaja de este método sobre los métodos que involucran la conexión wces que puede especificar varios archivos y obtener un recuento separado para cada archivo:

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

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

'wc' cuenta líneas, palabras, caracteres, así que para contar todas las líneas (incluidas las en blanco) use:

wc *.py

Para filtrar las líneas en blanco, puede usar grep:

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

'-v' le dice a grep que muestre todas las líneas excepto aquellas que coinciden con '^' 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 Todos los archivos que desea contar (todos los archivos de Python en el directorio actual) se envían a wc. Ya te vas.

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

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

cat file.txt | awk 'NF' | wc -l

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

debería hacer el truco bien

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

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 comentarios de varias líneas).

Aquí hay un script Bash que cuenta las líneas de código en un proyecto. Atraviesa un árbol de origen de forma recursiva 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

Así es como se ve la salida para mi proyecto :

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

Depende un poco de la cantidad de archivos que tenga en el proyecto. En teoría podrías usar

grep -c '.' <list of files>

Donde puede llenar la lista de archivos utilizando la utilidad find.

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

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

Script para contar recursivamente todas las líneas no 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;

Uso de la muestra:

./countlines.sh .py .java .html

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

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

El primer argumento 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.

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

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

HTH!

Esto proporciona el recuento de la cantidad de líneas sin contar las líneas en blanco:

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

rgrep . | wc -l

da el recuento de líneas no en blanco en el directorio de trabajo actual.

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.