Contar Linhas de Código com CLOC

LinuxBeginner
Pratique Agora

Introdução

CLOC (Count Lines of Code) é uma ferramenta de linha de comando que analisa os arquivos em um diretório e conta o número de linhas de código, comentários e linhas em branco em uma ampla variedade de linguagens de programação. É um recurso inestimável para desenvolvedores que buscam entender a composição de seus projetos, medir a produtividade ou estimar a complexidade do projeto.

Interface da ferramenta CLOC
Este é um Lab Guiado, que fornece instruções passo a passo para ajudá-lo a aprender e praticar. Siga as instruções cuidadosamente para completar cada etapa e ganhar experiência prática. Dados históricos mostram que este é um laboratório de nível iniciante com uma taxa de conclusão de 97%. Recebeu uma taxa de avaliações positivas de 99% dos estudantes.

Entendendo o CLOC e Seu Uso Básico

CLOC (Count Lines of Code) é um utilitário poderoso que ajuda os desenvolvedores a analisar sua base de código, contando as linhas de código, comentários e linhas em branco em várias linguagens de programação.

Neste passo, aprenderemos como usar o CLOC com sua sintaxe básica para analisar um projeto.

Comando Básico do CLOC

A sintaxe básica para usar o CLOC é:

cloc [opções] <arquivo/diretório>

Vamos usar o CLOC para analisar o projeto Flask que foi clonado durante a configuração:

  1. Abra o terminal clicando no ícone do terminal na barra de tarefas
  2. Navegue até o diretório do projeto Flask:
cd ~/project/flask
  1. Execute o comando básico do CLOC para analisar todo o projeto:
cloc .

O . representa o diretório atual, então este comando diz ao CLOC para analisar todos os arquivos no diretório atual e seus subdiretórios.

Entendendo a Saída

Após executar o comando, o CLOC exibirá uma tabela com as seguintes informações:

  • Language (Linguagem): Linguagens de programação detectadas no projeto
  • Files (Arquivos): Número de arquivos para cada linguagem
  • Blank (Em branco): Número de linhas em branco
  • Comment (Comentário): Número de linhas de comentário
  • Code (Código): Número de linhas de código

A saída deve ser semelhante a esta:

      56 text files.
      56 unique files.
      16 files ignored.

github.com/AlDanial/cloc v 1.90  T=0.11 s (428.1 files/s, 72093.6 lines/s)
--------------------------------------------------------------------------------
Language                      files          blank        comment           code
--------------------------------------------------------------------------------
Python                           41           3061           2088           7012
Markdown                          5            175              0            314
YAML                              2             10              3             84
make                              1             21             30             46
TOML                              1              6              0             19
--------------------------------------------------------------------------------
SUM:                             50           3273           2121           7475
--------------------------------------------------------------------------------

Esta saída fornece uma visão geral abrangente da composição da base de código do projeto Flask.

✨ Verificar Solução e Praticar

Analisando Tipos de Arquivos Específicos com CLOC

O CLOC permite que você analise tipos de arquivos específicos ou exclua certos arquivos de sua análise. Isso é particularmente útil ao trabalhar com projetos grandes que contêm várias linguagens de programação.

Analisando Extensões de Arquivos Específicas

Para analisar apenas arquivos com extensões específicas, você pode usar a opção --include-ext seguida por uma lista separada por vírgulas de extensões de arquivo:

  1. Navegue até o diretório do projeto Flask, se você ainda não estiver lá:
cd ~/project/flask
  1. Execute o CLOC para analisar apenas arquivos Python no projeto:
cloc --include-ext=py .

A saída agora mostrará apenas informações sobre arquivos Python no projeto:

      41 text files.
      41 unique files.
       0 files ignored.

github.com/AlDanial/cloc v 1.90  T=0.05 s (886.0 files/s, 264066.7 lines/s)
-------------------------------------------------------------------------------
Language                     files          blank        comment           code
-------------------------------------------------------------------------------
Python                          41           3061           2088           7012
-------------------------------------------------------------------------------
SUM:                            41           3061           2088           7012
-------------------------------------------------------------------------------

Excluindo Diretórios Específicos

Você também pode excluir diretórios específicos de sua análise usando a opção --exclude-dir:

cloc --exclude-dir=tests .

Este comando analisa o projeto Flask, mas exclui o diretório tests. A saída mostrará estatísticas para todos os arquivos do projeto, exceto aqueles no diretório tests:

      34 text files.
      34 unique files.
      14 files ignored.

github.com/AlDanial/cloc v 1.90  T=0.07 s (372.3 files/s, 45941.8 lines/s)
--------------------------------------------------------------------------------
Language                      files          blank        comment           code
--------------------------------------------------------------------------------
Python                           25           1546           1103           3421
Markdown                          5            175              0            314
YAML                              2             10              3             84
make                              1             21             30             46
TOML                              1              6              0             19
--------------------------------------------------------------------------------
SUM:                             34           1758           1136           3884
--------------------------------------------------------------------------------

Ao usar essas opções de filtragem, você pode concentrar sua análise em partes específicas da base de código que são mais relevantes para suas necessidades.

✨ Verificar Solução e Praticar

Comparando Projetos e Gerando Relatórios

O CLOC oferece recursos para comparar diferentes projetos e gerar relatórios em vários formatos. Essas capacidades são particularmente úteis para rastrear mudanças ao longo do tempo ou comparar diferentes bases de código.

Comparando Dois Diretórios

Vamos criar um projeto simples para comparar com o Flask:

  1. Navegue até o diretório do projeto:
cd ~/project
  1. Crie um novo diretório para um projeto Python simples:
mkdir sample_project
cd sample_project
  1. Crie alguns arquivos Python com algum código:
echo 'def hello_world():
    """
    A simple function that prints Hello World
    """
    print("Hello, World!")

if __name__ == "__main__":
    hello_world()' > main.py
echo 'class Calculator:
    """A simple calculator class"""
    
    def add(self, a, b):
        """Add two numbers"""
        return a + b
        
    def subtract(self, a, b):
        """Subtract b from a"""
        return a - b' > calculator.py
  1. Agora, vamos comparar este projeto de exemplo com o projeto Flask usando o recurso de diff do CLOC:
cd ~/project
cloc --diff flask sample_project

A saída mostrará a diferença nas métricas de código entre os dois projetos:

       2 text files.
       2 unique files.
       0 files ignored.

github.com/AlDanial/cloc v 1.90  T=0.01 s (195.2 files/s, 1756.8 lines/s)
-------------------------------------------------------------------------------
Language                     files          blank        comment           code
-------------------------------------------------------------------------------
Python                           2              3              4             11
-------------------------------------------------------------------------------
SUM:                             2              3              4             11
-------------------------------------------------------------------------------

Diff by file type:
-------------------------------------------------------------------------------
Language                     files          blank        comment           code
-------------------------------------------------------------------------------
Python                          39           3058           2084           7001
Markdown                         5            175              0            314
YAML                             2             10              3             84
make                             1             21             30             46
TOML                             1              6              0             19
-------------------------------------------------------------------------------
SUM:                            48           3270           2117           7464
-------------------------------------------------------------------------------

Gerando Relatórios em Diferentes Formatos

O CLOC pode gerar relatórios em vários formatos, incluindo CSV e XML. Vamos criar um relatório CSV para o projeto Flask:

  1. Navegue até o projeto Flask:
cd ~/project/flask
  1. Gere um relatório CSV:
cloc --csv --out=flask_stats.csv .
  1. Visualize o conteúdo do relatório gerado:
cat flask_stats.csv

Você deve ver a análise do CLOC em formato CSV:

files,language,blank,comment,code,"github.com/AlDanial/cloc v 1.90 T=0.09 s (571.3 files/s, 96263.8 lines/s)"
41,Python,3061,2088,7012
5,Markdown,175,0,314
2,YAML,10,3,84
1,make,21,30,46
1,TOML,6,0,19
50,SUM,3273,2121,7475

Este formato CSV é particularmente útil para importar em planilhas ou outras ferramentas de análise de dados.

Da mesma forma, você pode gerar um relatório XML:

cloc --xml --out=flask_stats.xml .

Esses recursos de relatório tornam o CLOC uma ferramenta versátil para análise de código e gerenciamento de projetos.

✨ Verificar Solução e Praticar

Opções Avançadas do CLOC para Análise Detalhada

O CLOC oferece diversas opções avançadas para uma análise mais detalhada e personalizada. Essas opções permitem que você obtenha insights mais profundos sobre sua base de código.

Mostrando o Progresso Durante a Análise

Ao analisar projetos grandes, é útil ver o progresso. Use a opção --progress-rate para exibir atualizações de progresso:

cd ~/project/flask
cloc --progress-rate=10 .

Este comando exibirá uma atualização de progresso após o processamento de cada 10 arquivos.

Analisando Arquivos que Correspondem a um Padrão

Você pode analisar arquivos que correspondem a um padrão específico usando a opção --match-f:

cloc --match-f='test_.*\.py$' .

Este comando conta as linhas de código apenas em arquivos Python que começam com "test_". A saída mostrará estatísticas para arquivos de teste no projeto Flask:

      15 text files.
      15 unique files.
       0 files ignored.

github.com/AlDanial/cloc v 1.90  T=0.03 s (541.8 files/s, 155547.1 lines/s)
-------------------------------------------------------------------------------
Language                     files          blank        comment           code
-------------------------------------------------------------------------------
Python                          15           1337            736           3193
-------------------------------------------------------------------------------
SUM:                            15           1337            736           3193
-------------------------------------------------------------------------------

Este recurso é particularmente útil quando você deseja se concentrar em padrões de arquivos específicos dentro de um projeto grande.

Exibindo Resultados por Arquivo

Para ver uma análise detalhada por arquivos individuais, em vez de apenas por linguagem, use a opção --by-file:

cloc --by-file --include-ext=py src/

Este comando analisa arquivos Python no diretório src e exibe resultados para cada arquivo individualmente:

    7 text files.
    7 unique files.
    0 files ignored.

github.com/AlDanial/cloc v 1.90  T=0.01 s (648.3 files/s, 180431.1 lines/s)
-------------------------------------------------------------------------------
File                          blank        comment           code
-------------------------------------------------------------------------------
src/flask/ctx.py                123            193            539
src/flask/app.py                284            490            999
src/flask/blueprints.py         100            191            421
src/flask/cli.py                126            188            557
src/flask/helpers.py            136            227            538
src/flask/templating.py          28             60            123
src/flask/globals.py             22             63             74
-------------------------------------------------------------------------------
SUM:                            819           1412           3251
-------------------------------------------------------------------------------

Esta visualização detalhada ajuda você a identificar quais arquivos específicos contribuem mais para o tamanho da sua base de código.

Essas opções avançadas tornam o CLOC uma ferramenta versátil para análise de código abrangente em vários cenários.

✨ Verificar Solução e Praticar

Resumo

Neste laboratório, você aprendeu como usar o CLOC (Count Lines of Code) para analisar bases de código e obter informações valiosas sobre a composição do projeto. Aqui está um resumo do que você realizou:

  1. Uso Básico: Você aprendeu a usar o comando básico cloc para analisar diretórios e contar linhas de código, comentários e linhas em branco em diferentes linguagens de programação.

  2. Filtragem e Direcionamento: Você explorou como focar sua análise em tipos de arquivos específicos usando --include-ext e como excluir diretórios com --exclude-dir.

  3. Comparação e Relatórios: Você aprendeu como comparar diferentes bases de código usando a opção --diff e como gerar relatórios em vários formatos, como CSV e XML.

  4. Análise Avançada: Você descobriu opções avançadas que fornecem insights mais detalhados, como rastreamento de progresso, detecção de arquivos duplicados, correspondência de padrões e análise arquivo por arquivo.

O CLOC é uma ferramenta poderosa para desenvolvedores, gerentes de projeto e auditores de código quantificarem o tamanho e a complexidade das bases de código. Ao usar o CLOC de forma eficaz, você pode:

  • Compreender a composição de seus projetos
  • Acompanhar a produtividade da codificação
  • Estimar a complexidade do projeto
  • Tomar decisões informadas sobre a arquitetura e manutenção do código
  • Gerar relatórios para documentação e análise

Essas capacidades tornam o CLOC uma ferramenta essencial no kit de ferramentas de qualquer desenvolvedor para análise de código e gerenciamento de projetos.