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

#!/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 recursivamente).

En lo anterior "./blog" "./ punbb""./ js / 3rdparty "and"./ pma " son carpetas que pongo 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 es ignorado.

Si quieres usar algo que no sea un script de shell, prueba CLOC :

Cloc cuenta líneas en blanco, comentario líneas y líneas físicas de origen código en muchos lenguajes de programación. Se está escrito enteramente en Perl con no dependencias fuera del estándar distribución de Perl v5. 6 y superior (el código de algunos módulos externos es integrado dentro de la cloc) y así es bastante portátil.

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

Mi solución es:

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

Esto busca líneas en las líneas no coinciden (-v) que coinciden con el patrón (-e) '^\s*^', que es el principio de una línea, seguido de 0 o más caracteres de espacio en blanco, seguido por el final de una línea (ie. no hay contenido que no sea espacios en blanco), y muestra un recuento de líneas coincidentes (-c) en lugar de las líneas coincidentes en sí.

Una ventaja de este método sobre los métodos eso implica canalizar hacia wc, es 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, por lo 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 coincidan '^'es el comienzo de una línea '\s* ' es cero o más caracteres de espacio en blanco '$' es el final de una línea *. py es mi ejemplo para todos los archivos que desea contar (todos los archivos python en el directorio actual) salida de la tubería al wc. Vete.

Estoy respondiendo a mi propio (genuino) pregunta. No pude encontrar una entrada de Stackoverflow que cubriera esto.

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

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

Debería hacer el truco muy bien

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

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

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

Aquí hay un script Bash que cuenta las líneas de código en un proyecto. Atraviesa un árbol de fuentes recursivamente, y excluye líneas en blanco y 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

Disfrute! -- Curran

Va a depender un poco del número de archivos que tenga en el proyecto. En teoría se podría utilizar

grep -c '.' <list of files>

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

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

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

Script para contar recursivamente todas las líneas no en blanco con una cierta 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 no en blanco para todos los archivos de 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, 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.

Esto da la cuenta del número de líneas sin contar las líneas en blanco:

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

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!

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

Solo

wc -l *.c 

Y le da las líneas totales y las líneas para cada archivo.