bash - programas - script linux ejemplos

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

Question

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

Answer 1

''wc'' cuenta líneas, palabras, caracteres, así que para contar todas las líneas (incluidas las vacías) 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 python en el directorio actual) generan salida en wc. Listo.

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

Answer 2

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

Aquí se muestra el resultado de 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 3

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

Answer 4

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

Answer 5

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

Mi solución es:

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

Esto busca líneas en <archivo> las líneas 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 caracteres en blanco, seguidos al final de una línea (es decir, sin contenido distinto del espacio en blanco), y muestra un recuento de líneas correspondientes (-c) en lugar de las líneas correspondientes.

Una ventaja de este método con respecto a los métodos que implican conectar con wc es que puede especificar múltiples 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

Answer 6

Secuencia de comandos para recursivamente contar 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 muestra:

./countlines.sh .py .java .html

Answer 7

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

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

Si desea usar algo que no sea un script de shell, intente CLOC :

cloc cuenta líneas en blanco, líneas de comentario 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á integrado dentro de cloc) y, por lo tanto, es bastante portátil.

Answer 9

Va a depender 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 usando la herramienta de búsqueda.

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

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

Answer 10

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

Sólo

wc -l *.c 

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

Answer 11

#!/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 el anterior "./blog" "./punbb" "./js/3rdparty" y "./pma" son carpetas que incluyo 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.

Answer 12

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

Answer 13

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

debería hacer el truco bien

Answer 14

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

Y si considera los comentarios líneas en blanco:

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

Aunque, eso depende del idioma.

Answer 15

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 16

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 17

rgrep . | wc -l

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