Quantidade (não em branco) linhas-de-código em festa

Question

Em Bash, como faço para contar o número de linhas de código não-branco em um projeto?

Answer 1

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

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

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

Embora, desse idioma dependente.

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

O acima lhe dará a contagem total de linhas de código (linhas em branco removidos) para um projeto (pasta atual e todas as subpastas recursivamente).

No exemplo acima "./blog" "./punbb" "./js/3rdparty" e "./pma" são pastas que lista negra como eu não escrever o código em si. Também .php, .as, .sql, .css, .js são as extensões dos arquivos que estão sendo olhados. Qualquer arquivo com uma extensão diferente são ignorados.

Answer 3

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

cloc conta as linhas em branco, comentário linhas, e as linhas físicas da fonte código em várias linguagens de programação. isto é inteiramente escrito em Perl sem dependências fora do padrão distribuição de Perl v5.6 e maior (Código de alguns módulos externos é incorporado dentro CLOC) e por isso é bastante portátil.

Answer 4

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

A minha solução é:

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

Isto procura por linhas em a não coincidirem (-v) linhas que correspondem ao padrão (-e) '^ \ s * $', que é o início de uma linha, seguido por 0 ou mais espaços em branco caracteres, seguido pela extremidade de uma linha (isto é. não outros conteúdos, em seguida, os espaços em branco), e apresentar uma contagem de linhas correspondentes (-c), em vez das linhas de coordenação si.

Uma vantagem deste método em relação aos métodos que envolvem tubulação em 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

Answer 5

'wc' contagens de linhas, palavras, caracteres, de modo a contar todas as linhas (incluindo os em branco) use:

wc *.py

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

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

'- v' diz grep a saída de todas as linhas, exceto aqueles que jogo '^' É o início de uma linha '\ S *' é zero ou mais espaços em branco caracteres '$' É o fim de uma linha * .Py é o meu exemplo para todos os arquivos que você deseja para contar (todos os arquivos Python em dir atual) saída de tubo de WC. Temos que ir.

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

Answer 6

Este número de contagem de comando de linhas não-branco.
cat fileName | grep -v ^$ | wc -l
grep -v ^ $ função expressão regular é ignorar linhas em branco.

Answer 7

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

deve fazer o truque muito bem

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

eu postar este becaus outras opções deu respostas erradas para mim. Isso funcionou com a minha fonte de Java, onde as linhas de comentário começam com / ou * (i usar * em cada linha em comentário multi-linha).

Answer 9

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

Answer 10

Aqui está um script Bash que conta as linhas de código em um projeto. Atravessa uma árvore fonte de forma recursiva, e exclui linhas em branco e comentários única linha que uso "//".

# $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á o que os olhares de saída como para 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

Divirta-se! - Curran

Answer 11

Vai meio a depender do número de arquivos que você tem no projeto. Em teoria, você poderia usar

grep -c '.' <list of files>

Onde você pode preencher a lista de arquivos usando o utilitário achado.

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

iria dar-lhe uma contagem linha por arquivo.

Answer 12

Script para contar de forma recursiva todas as linhas não-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;

Exemplo de uso:

./countlines.sh .py .java .html

Answer 13

Se você quer a soma de todas as linhas não-branco para todos os arquivos de um determinado extensão de arquivo longo de um projeto:

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

Primeiro arg é o diretório base do projeto, o segundo é a extensão do arquivo. Exemplo de uso:

./scriptname ~/Dropbox/project/src java

É pouco mais do que um conjunto de soluções anteriores.

Answer 14

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

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

HTH!

Answer 15

Isto dá a contagem de número de linhas sem contar as linhas em branco:

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

Answer 16

rgrep . | wc -l

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

Answer 17

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

Apenas

wc -l *.c 

e dá-lhe total de linhas e as linhas para cada arquivo.