Como contar todas as linhas de código em um diretório recursivamente?

Temos um aplicativo PHP e queremos contar todas as linhas de código em um diretório específico e seus subdiretórios. Não precisamos ignorar comentários, pois estamos apenas tentando ter uma idéia aproximada.

wc -l *.php 

Esse comando funciona muito bem em um determinado diretório, mas ignora os subdiretórios. Eu estava pensando que isso poderia funcionar, mas está retornando 74, o que definitivamente não é o caso ...

find . -name '*.php' | wc -l

Qual é a sintaxe correta para alimentar todos os arquivos?

Tentar:

find . -name '*.php' | xargs wc -l

A ferramenta SLOCCount pode ajudar.

Ele fornecerá uma contagem precisa de linhas de código fonte para qualquer hierarquia que você apontar, além de algumas estatísticas adicionais.

Saída classificada:

find . -name '*.php' | xargs wc -l | sort -nr

Para outro one-liner:

( find ./ -name '*.php' -print0 | xargs -0 cat ) | wc -l

funciona em nomes com espaços, gera apenas um número.

Se estiver usando uma versão decentemente recente do Bash (ou ZSH), é muito mais simples:

wc -l **/*.php

No shell Bash, isso requer que a globstaropção seja definida, caso contrário, o **operador glob não é recursivo. Para habilitar essa configuração, emita

shopt -s globstar

Para tornar isso permanente, adicione-o a um dos arquivos de inicialização ( ~/.bashrc, ~/.bash_profileetc.).

Você pode usar o cloc utilitário criado para esse fim exato. Ele informa cada quantidade de linhas em cada idioma, juntamente com quantas delas são comentários, etc. O CLOC está disponível no Linux, Mac e Windows.

Exemplo de uso e saída:

$ cloc --exclude-lang=DTD,Lua,make,Python .
    2570 text files.
    2200 unique files.                                          
    8654 files ignored.

http://cloc.sourceforge.net v 1.53  T=8.0 s (202.4 files/s, 99198.6 lines/s)
-------------------------------------------------------------------------------
Language                     files          blank        comment           code
-------------------------------------------------------------------------------
Javascript                    1506          77848         212000         366495
CSS                             56           9671          20147          87695
HTML                            51           1409            151           7480
XML                              6           3088           1383           6222
-------------------------------------------------------------------------------
SUM:                          1619          92016         233681         467892
-------------------------------------------------------------------------------

Em sistemas do tipo UNIX, existe uma ferramenta chamada clocque fornece estatísticas de código.

Corri em um diretório aleatório em nossa base de código que diz:

      59 text files.
      56 unique files.                              
       5 files ignored.

http://cloc.sourceforge.net v 1.53  T=0.5 s (108.0 files/s, 50180.0 lines/s)
-------------------------------------------------------------------------------
Language                     files          blank        comment           code
-------------------------------------------------------------------------------
C                               36           3060           1431          16359
C/C++ Header                    16            689            393           3032
make                             1             17              9             54
Teamcenter def                   1             10              0             36
-------------------------------------------------------------------------------
SUM:                            54           3776           1833          19481
-------------------------------------------------------------------------------

Você não especificou quantos arquivos existem ou qual é a saída desejada. É isso que você está procurando:

find . -name '*.php' | xargs wc -l

Ainda outra variação :)

$ find . -name '*.php' | xargs cat | wc -l

Edit: isso dará a soma total, em vez de arquivo por arquivo.

Edit2: Adicione .depois findpara fazê-lo funcionar

Surpreendentemente, não há resposta baseada em encontrar -exece awk. Aqui vamos nós:

find . -type f -exec wc -l {} \; | awk '{ SUM += $0} END { print SUM }'

Este trecho encontra para todos os arquivos ( -type f). Para localizar por extensão de arquivo, use -name:

find . -name '*.py' -exec wc -l '{}' \; | awk '{ SUM += $0; } END { print SUM; }'

Mais comum e simples quanto a mim, suponha que você precise contar arquivos de diferentes extensões de nome (digamos, também nativos)

wc $(find . -type f | egrep "\.(h|c|cpp|php|cc)" )

Obrigado pelo feedback, eu o corrigi.

POSIX

Diferentemente da maioria das outras respostas aqui, elas funcionam em qualquer sistema POSIX, para qualquer número de arquivos e com qualquer nome de arquivo (exceto onde indicado).

Linhas em cada arquivo:

find . -name '*.php' -type f -exec wc -l {} \;
# faster, but includes total at end if there are multiple files
find . -name '*.php' -type f -exec wc -l {} +

Linhas em cada arquivo, classificadas pelo caminho do arquivo

find . -name '*.php' -type f | sort | xargs -L1 wc -l
# for files with spaces or newlines, use the non-standard sort -z
find . -name '*.php' -type f -print0 | sort -z | xargs -0 -L1 wc -l

Linhas em cada arquivo, classificadas por número de linhas, decrescente

find . -name '*.php' -type f -exec wc -l {} \; | sort -nr
# faster, but includes total at end if there are multiple files
find . -name '*.php' -type f -exec wc -l {} + | sort -nr

Total de linhas em todos os arquivos

find . -name '*.php' -type f -exec cat {} + | wc -l

Existe uma pequena ferramenta chamada sloccount para contar as linhas de código no diretório Deve-se notar que ele faz mais do que você deseja, pois ignora linhas / comentários vazios, agrupa os resultados por linguagem de programação e calcula algumas estatísticas.

O que você quer é um forloop simples :

total_count=0
for file in $(find . -name *.php -print)
do
    count=$(wc -l $file)
    let total_count+=count
done
echo "$total_count"

apenas para fontes:

wc `find`

para filtrar, basta usar grep

wc `find | grep .php$`

Um simples que será rápido, usará todo o poder de pesquisa / filtragem de find, não falhará quando houver muitos arquivos (excesso de argumentos numéricos), funcionará bem com arquivos com símbolos engraçados em seu nome, sem usar xargs, não iniciará um número inutilmente alto de comandos externos (graças a +for find's -exec). Aqui está:

find . -name '*.php' -type f -exec cat -- {} + | wc -l

Eu sei que a pergunta está marcada como bater, mas parece que o problema que você está tentando resolver também está relacionado ao PHP.

Sebastian Bergmann escreveu uma ferramenta chamada PHPLOC que faz o que você deseja e, além disso, fornece uma visão geral da complexidade de um projeto. Este é um exemplo de seu relatório:

Size
  Lines of Code (LOC)                            29047
  Comment Lines of Code (CLOC)                   14022 (48.27%)
  Non-Comment Lines of Code (NCLOC)              15025 (51.73%)
  Logical Lines of Code (LLOC)                    3484 (11.99%)
    Classes                                       3314 (95.12%)
      Average Class Length                          29
      Average Method Length                          4
    Functions                                      153 (4.39%)
      Average Function Length                        1
    Not in classes or functions                     17 (0.49%)

Complexity
  Cyclomatic Complexity / LLOC                    0.51
  Cyclomatic Complexity / Number of Methods       3.37

Como você pode ver, as informações fornecidas são muito mais úteis da perspectiva de um desenvolvedor, porque podem dizer a grosso modo como um projeto é complexo antes de começar a trabalhar com ele.

Acho que ninguém nunca verá isso enterrado na parte de trás ... No entanto, nenhuma das respostas até agora aborda o problema de nomes de arquivos com espaços. Além disso, todo esse uso xargsestá sujeito a falha se o comprimento total dos caminhos na árvore exceder o limite de tamanho do ambiente de shell (o padrão é alguns megabytes no Linux). Aqui está um que resolve esses problemas de maneira bastante direta. O subshell cuida de arquivos com espaços. oawk total do fluxo de wcsaídas de arquivos individuais , portanto, nunca deve ficar sem espaço. Também restringe execapenas os arquivos (pulando diretórios):

find . -type f -name '*.php' -exec bash -c 'wc -l "$0"' {} \; | awk '{s+=$1} END {print s}' 

WC -L? use melhor o GREP -C ^

wc -l? Errado! O comando wc conta novos códigos de linha, não linhas! Quando a última linha do arquivo não termina com o novo código de linha, isso não conta!

Se você ainda deseja contar linhas, use grep -c ^ , exemplo completo:

#this example prints line count for all found files
total=0
find /path -type f -name "*.php" | while read FILE; do
     #you see use grep instead wc ! for properly counting
     count=$(grep -c ^ < "$FILE")
     echo "$FILE has $count lines"
     let total=total+count #in bash, you can convert this for another shell
done
echo TOTAL LINES COUNTED:  $total

finalmente, cuidado com a armadilha wc -l (conta entra, não linhas !!!)

muito simplesmente

find /path -type f -name "*.php" | while read FILE
do
    count=$(wc -l < $FILE)
    echo "$FILE has $count lines"
done

Se você deseja que seus resultados sejam classificados por número de linhas, basta adicionar | sortou | sort -r( -rpor ordem decrescente) à primeira resposta, da seguinte forma:

find . -name '*.php' | xargs wc -l | sort -r

Para Windows , a ferramenta fácil e rápida é o LocMetrics .

Algo diferente:

wc -l `tree -if --noreport | grep -e'\.php$'`

Isso funciona bem, mas você precisa ter pelo menos um *.phparquivo na pasta atual ou em uma de suas subpastas, ou wcparar

Se você estiver no Linux (e acredito que esteja), recomendo minha ferramenta poliglota . É dramaticamente mais rápido que um sloccountou mais cloce é mais abrangente que sloccount.

Você pode invocá-lo com

poly .

ou

poly

portanto, é muito mais fácil de usar do que algum script bash complicado.

É muito fácil com os zsh globs:

wc -l ./**/*.php

Se você estiver usando o bash, basta atualizar. Não há absolutamente nenhuma razão para usar o bash.

A ferramenta Tokei exibe estatísticas sobre o código em um diretório. Tokei mostrará o número de arquivos, o total de linhas dentro desses arquivos e o código, os comentários e os espaços em branco agrupados por idioma. Tokei também está disponível no Mac, Linux e Windows.

Um exemplo da saída de Tokei é o seguinte:

$ tokei
-------------------------------------------------------------------------------
 Language            Files        Lines         Code     Comments       Blanks
-------------------------------------------------------------------------------
 CSS                     2           12           12            0            0
 JavaScript              1          435          404            0           31
 JSON                    3          178          178            0            0
 Markdown                1            9            9            0            0
 Rust                   10          408          259           84           65
 TOML                    3           69           41           17           11
 YAML                    1           30           25            0            5
-------------------------------------------------------------------------------
 Total                  21         1141          928          101          112
-------------------------------------------------------------------------------

O Tokei pode ser instalado seguindo as instruções no arquivo README no repositório .

Se você precisar apenas do número total de linhas, digamos seus arquivos PHP, você pode usar um comando de uma linha muito simples, mesmo no Windows, se o GnuWin32 estiver instalado. Como isso:

cat `/gnuwin32/bin/find.exe . -name *.php` | wc -l

Você precisa especificar onde exatamente está o find.exe, caso contrário, o FIND.EXE fornecido pelo Windows (a partir dos antigos comandos semelhantes ao DOS) será executado, pois provavelmente antes do GnuWin32 no ambiente PATH e possui parâmetros e resultados diferentes.

Observe que no comando acima você deve usar aspas duplas, não aspas simples.

Distribuindo os arquivos mais longos primeiro (ou seja, talvez esses arquivos longos precisem de um pouco de refatoração?) E excluindo alguns diretórios de fornecedores:

 find . -name '*.php' | xargs wc -l | sort -nr | egrep -v "libs|tmp|tests|vendor" | less

Se você quiser simplificar, recorte o intermediário e ligue wccom todos os nomes de arquivos:

wc -l `find . -name "*.php"`

Ou na sintaxe moderna:

wc -l $(find . -name "*.php")

Funciona desde que não haja espaços em nenhum dos nomes de diretório ou nomes de arquivos. E desde que você não tenha dezenas de milhares de arquivos (os shells modernos suportam linhas de comando realmente longas). Seu projeto possui 74 arquivos, portanto você tem muito espaço para crescer.

Você não precisa de todos esses comandos complicados e difíceis de lembrar. Você só precisa de uma ferramenta chamada contador de linhas .

Uma rápida visão geral

É assim que você obtém a ferramenta

$ pip install line-counter

Use o linecomando para obter a contagem de arquivos e a linha no diretório atual (recursivamente)

$ line
Search in /Users/Morgan/Documents/Example/
file count: 4
line count: 839

Se você quiser mais detalhes, basta usar line -d.

$ line -d
Search in /Users/Morgan/Documents/Example/
Dir A/file C.c                                             72
Dir A/file D.py                                           268
file A.py                                                 467
file B.c                                                   32
file count: 4
line count: 839

E a melhor parte dessa ferramenta é que você pode adicionar .gitignoreum arquivo de configuração. Você pode configurar regras para selecionar ou ignorar que tipo de arquivos contar, exatamente como o que você faz em '.gitignore'.

Mais descrição e uso estão aqui: https://github.com/MorganZhang100/line-counter

Se os arquivos forem muitos, é melhor procurar apenas a contagem total de linhas.

find . -name '*.php' | xargs wc -l | grep -i ' total' | awk '{print $1}'

Pelo menos no OS X, os comandos find + xarg + wc listados em algumas das outras respostas imprimem "total" várias vezes em listagens grandes e não há um total completo. Consegui obter um total único para arquivos .c usando o seguinte comando:

find . -name '*.c' -print0 |xargs -0 wc -l|grep -v total|awk '{ sum += $1; } END { print "SUM: " sum; }'