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

Question

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

Answer 1

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

Y si consideras comentarios líneas en blanco:

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

Aunque eso depende del idioma.

Answer 2

#!/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 (se eliminaron las líneas en blanco) para un proyecto (carpeta actual y todas las subcarpetas de forma recursiva).

En lo 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 analizando.Se ignoran todos los archivos con una extensión diferente.

Answer 3

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

CLOC cuenta las líneas en blanco, las líneas de comentarios y las líneas físicas del código fuente en muchos lenguajes de programación.Se escribe completamente en Perl sin dependencias fuera de la distribución estándar de Perl V5.6 y más alto (el código de algunos módulos externos está integrado dentro de los CLOC) y, por lo tanto, es bastante portátil.

Answer 4

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> que no coincidan (-v) líneas que coincidan con el patrón (-e) '^\s*$', que es el comienzo de una línea, seguido de 0 o más caracteres de espacio en blanco, seguido al final de una línea (es decir.ningún contenido más que espacios en blanco) y muestra un recuento de líneas coincidentes (-c) en lugar de las líneas coincidentes mismas.

Una ventaja de este método sobre los métodos que involucran tuberías en wc, es que puede especificar varios archivos y obtener un recuento independiente para cada archivo:

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

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

Answer 5

'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, puedes usar grep:

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

'-V' le dice a Grep que emite todas las líneas, excepto las que coinciden, '^' es el inicio de una línea ' S *' es cero o más caracteres 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 la salida de tubería de Dir) a WC.Ya te vas.

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

Answer 6

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

Answer 7

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

debería funcionar bien

Answer 8

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 Java, donde las líneas de comentarios comienzan con / o * (yo uso * en cada línea en un comentario de varias líneas).

Answer 9

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

Answer 10

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

Answer 11

Dependerá 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 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 12

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

Uso de muestra:

./countlines.sh .py .java .html

Answer 13

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

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

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

./scriptname ~/Dropbox/project/src java

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

Answer 14

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

proporciona un recuento agregado de todos los archivos en el directorio actual y sus subdirectorios.

¡HH!

Answer 15

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

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

Answer 16

rgrep . | wc -l

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

Answer 17

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

Justo

wc -l *.c 

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