contar linhas de código (não em branco) no bash

No Bash, como posso contar o número de linhas de código não em branco em um projeto?

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

E se você considerar os comentários em linhas em branco:

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

Embora isso seja dependente da linguagem.

#!/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

A descrição acima fornecerá a contagem total de linhas de código (linhas em branco removidas) para um projeto (pasta atual e todas as subpastas recursivamente).

Nas opções "./blog" "./punbb" "./js/3rdparty" e "./pma" acima estão as pastas que eu lista negra, pois não escrevi o código nelas. Também .php, .as, .sql, .css, .js são as extensões dos arquivos que estão sendo visualizados. Quaisquer arquivos com uma extensão diferente são ignorados.

Se você deseja usar algo diferente de um script de shell, tente CLOC :

O cloc conta linhas em branco, linhas de comentários e linhas físicas do código fonte em muitas linguagens de programação. Ele foi escrito inteiramente em Perl, sem dependências fora da distribuição padrão do Perl v5.6 e superior (o código de alguns módulos externos está incorporado no cloc) e, portanto, é bastante portátil.

Há muitas maneiras de fazer isso, usando utilitários comuns do shell.

Minha solução é:

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

Ele procura por linhas no <arquivo> as linhas que não correspondem (-v) que correspondem ao padrão (-e) '^ \ s * $', que é o início de uma linha, seguido por 0 ou mais caracteres de espaço em branco, seguidos no final de uma linha (ou seja, nenhum conteúdo que não seja espaço em branco) e exiba uma contagem de linhas correspondentes (-c) em vez das próprias linhas correspondentes.

Uma vantagem desse método em relação aos métodos que envolvem canalização wcé que você pode especificar vários arquivos e obter uma contagem separada para cada arquivo:

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

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

'wc' conta linhas, palavras, caracteres, para contar todas as linhas (incluindo as em branco) use:

wc *.py

Para filtrar as linhas em branco, você pode usar grep:

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

'-v' diz ao grep para produzir todas as linhas, exceto aquelas que correspondem a '^' é o início de uma linha '\ s *' é zero ou mais caracteres em branco '$' é o final de uma linha * .py é o meu exemplo para todos os arquivos que você deseja contar (todos os arquivos python no diretório atual) canalizam a saída para o wc. Lá vai você.

Estou respondendo minha própria pergunta (genuína). Não foi possível encontrar uma entrada de stackoverflow que cobria isso.

Este comando conta o número de linhas que não estão em branco.
cat fileName | grep -v ^$ | wc -l
A função de expressão regular grep -v ^ $ ignora as linhas em branco.

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

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

deve fazer o truque muito bem

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

Eu posto isso porque outras opções deram respostas erradas para mim. Isso funcionou com minha fonte java, onde as linhas de comentário começam com / ou * (eu uso * em todas as linhas no comentário de várias linhas).

Aqui está um script Bash que conta as linhas de código em um projeto. Ele percorre uma árvore de origem recursivamente e exclui linhas em branco e comentários de linha única que usam "//".

# $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

Aqui está a aparência da saída para o meu projeto :

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

Aproveitar! - Curran

Depende do número de arquivos que você possui no projeto. Em teoria, você poderia usar

grep -c '.' <list of files>

Onde você pode preencher a lista de arquivos usando o utilitário de localização.

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

Daria a você uma contagem de linhas por arquivo.

Script para contar recursivamente todas as linhas que não estão em branco com uma certa extensão de arquivo no diretório atual:

#!/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 da amostra:

./countlines.sh .py .java .html

Se você deseja a soma de todas as linhas não em branco de todos os arquivos de uma determinada extensão de arquivo em um projeto:

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

O primeiro argumento é o diretório base do projeto, o segundo é a extensão do arquivo. Uso da amostra:

./scriptname ~/Dropbox/project/src java

É pouco mais do que uma coleção de soluções anteriores.

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

fornece uma contagem agregada para todos os arquivos no diretório atual e seus subdiretórios.

HTH!

Isso fornece a contagem do número de linhas sem contar as linhas em branco:

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

rgrep . | wc -l

fornece a contagem de linhas não em branco no diretório de trabalho atual.

Já existe um programa para isso no linux chamado 'wc'.

Somente

wc -l *.c 

e fornece o total de linhas e as linhas para cada arquivo.