Contar líneas de código con CLOC

LinuxLinuxBeginner
Practicar Ahora

💡 Este tutorial está traducido por IA desde la versión en inglés. Para ver la versión original, puedes hacer clic aquí

Introducción

CLOC (Contador de Líneas de Código) es una herramienta de línea de comandos que analiza los archivos en un directorio y cuenta el número de líneas de código, comentarios y líneas en blanco en una amplia variedad de lenguajes de programación. Es un recurso invaluable para los desarrolladores que buscan entender la composición de sus proyectos, medir la productividad o estimar la complejidad del proyecto.

Interfaz de la herramienta CLOC

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL linux(("Linux")) -.-> linux/BasicFileOperationsGroup(["Basic File Operations"]) linux(("Linux")) -.-> linux/PackagesandSoftwaresGroup(["Packages and Softwares"]) linux/BasicFileOperationsGroup -.-> linux/ls("Content Listing") linux/PackagesandSoftwaresGroup -.-> linux/wget("Non-interactive Downloading") subgraph Lab Skills linux/ls -.-> lab-273383{{"Contar líneas de código con CLOC"}} linux/wget -.-> lab-273383{{"Contar líneas de código con CLOC"}} end

Comprender CLOC y su Uso Básico

CLOC (Contador de Líneas de Código) es una poderosa utilidad que ayuda a los desarrolladores a analizar su base de código contando las líneas de código, comentarios y líneas en blanco en múltiples lenguajes de programación.

En este paso, aprenderemos cómo usar CLOC con su sintaxis básica para analizar un proyecto.

Comando Básico de CLOC

La sintaxis básica para usar CLOC es:

cloc [options] <file/directory>

Usemos CLOC para analizar el proyecto Flask que se clonó durante la configuración:

  1. Abra la terminal haciendo clic en el icono de la terminal en la barra de tareas.
  2. Navegue al directorio del proyecto Flask:
cd ~/project/flask
  1. Ejecute el comando básico de CLOC para analizar todo el proyecto:
cloc .

El . representa el directorio actual, por lo que este comando le dice a CLOC que analice todos los archivos en el directorio actual y sus subdirectorios.

Comprender la Salida

Después de ejecutar el comando, CLOC mostrará una tabla con la siguiente información:

  • Lenguaje: Lenguajes de programación detectados en el proyecto.
  • Archivos: Número de archivos para cada lenguaje.
  • En blanco: Número de líneas en blanco.
  • Comentario: Número de líneas de comentario.
  • Código: Número de líneas de código.

La salida debería verse algo así:

      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 salida le da una visión general completa de la composición de la base de código del proyecto Flask.

Analizar Tipos de Archivos Específicos con CLOC

CLOC te permite analizar tipos de archivos específicos o excluir ciertos archivos de tu análisis. Esto es especialmente útil cuando trabajas con proyectos grandes que contienen múltiples lenguajes de programación.

Analizar Extensiones de Archivos Específicas

Para analizar solo archivos con extensiones específicas, puedes usar la opción --include-ext seguida de una lista de extensiones de archivos separadas por comas:

  1. Navega al directorio del proyecto Flask si aún no estás allí:
cd ~/project/flask
  1. Ejecuta CLOC para analizar solo archivos Python en el proyecto:
cloc --include-ext=py .

La salida ahora solo mostrará información sobre los archivos Python en el proyecto:

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

Excluir Directorios Específicos

También puedes excluir directorios específicos de tu análisis usando la opción --exclude-dir:

cloc --exclude-dir=tests .

Este comando analiza el proyecto Flask pero excluye el directorio tests. La salida mostrará estadísticas para todos los archivos del proyecto excepto aquellos en el directorio 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
--------------------------------------------------------------------------------

Al usar estas opciones de filtrado, puedes centrar tu análisis en partes específicas de la base de código que son más relevantes para tus necesidades.

Comparar Proyectos y Generar Informes

CLOC ofrece funciones para comparar diferentes proyectos y generar informes en varios formatos. Estas capacidades son especialmente útiles para seguir los cambios a lo largo del tiempo o comparar diferentes bases de código.

Comparar Dos Directorios

Creemos un proyecto simple para comparar con Flask:

  1. Navegue al directorio del proyecto:
cd ~/project
  1. Cree un nuevo directorio para un proyecto simple de Python:
mkdir sample_project
cd sample_project
  1. Cree algunos archivos de Python con algún 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. Ahora, compare este proyecto de muestra con el proyecto Flask utilizando la función de comparación (diff) de CLOC:
cd ~/project
cloc --diff flask sample_project

La salida mostrará la diferencia en las métricas de código entre los dos proyectos:

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

Generar Informes en Diferentes Formatos

CLOC puede generar informes en varios formatos, incluyendo CSV y XML. Creemos un informe CSV para el proyecto Flask:

  1. Navegue al proyecto Flask:
cd ~/project/flask
  1. Genere un informe CSV:
cloc --csv --out=flask_stats.csv .
  1. Vea el contenido del informe generado:
cat flask_stats.csv

Debería ver el análisis de CLOC en 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 es especialmente útil para importar a hojas de cálculo u otras herramientas de análisis de datos.

Del mismo modo, puede generar un informe XML:

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

Estas capacidades de generación de informes hacen de CLOC una herramienta versátil para el análisis de código y la gestión de proyectos.

Opciones Avanzadas de CLOC para un Análisis Detallado

CLOC ofrece varias opciones avanzadas para un análisis más detallado y personalizado. Estas opciones te permiten obtener una comprensión más profunda de tu base de código.

Mostrar Progreso Durante el Análisis

Al analizar proyectos grandes, es útil ver el progreso. Utiliza la opción --progress-rate para mostrar actualizaciones de progreso:

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

Este comando mostrará una actualización de progreso después de procesar cada 10 archivos.

Contar Archivos Duplicados

CLOC puede identificar e informar sobre archivos duplicados en tu proyecto. Veamos cómo usar esta función:

cloc --duplicate-threshold=15 .

La opción --duplicate-threshold establece el porcentaje mínimo de código duplicado necesario para que dos archivos se consideren duplicados. En este ejemplo, estamos usando un umbral del 15%, lo que significa que los archivos que compartan al menos el 15% de su contenido se informarán como duplicados.

Si se encuentran duplicados, verás una salida que incluye información sobre los archivos duplicados:

Duplicate files:
[some file paths will be listed here]

Analizar Archivos que Coincidan con un Patrón

Puedes analizar archivos que coincidan con un patrón específico utilizando la opción --match-f:

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

Este comando cuenta las líneas de código solo en archivos Python que comiencen con "test_". La salida mostrará estadísticas para los archivos de prueba en el proyecto 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
-------------------------------------------------------------------------------

Esta función es especialmente útil cuando quieres centrarte en patrones de archivos específicos dentro de un proyecto grande.

Mostrar Resultados por Archivo

Para ver un desglose del análisis por archivos individuales en lugar de solo por lenguaje, utiliza la opción --by-file:

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

Este comando analiza archivos Python en el directorio src y muestra los resultados para cada archivo 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 vista detallada te ayuda a identificar qué archivos específicos contribuyen más al tamaño de tu base de código.

Estas opciones avanzadas hacen de CLOC una herramienta versátil para un análisis integral de código en diversos escenarios.

Resumen

En este laboratorio, has aprendido cómo usar CLOC (Count Lines of Code, Contador de Líneas de Código) para analizar bases de código y obtener información valiosa sobre la composición de proyectos. Aquí está un resumen de lo que has logrado:

  1. Uso Básico: Aprendiste cómo usar el comando básico cloc para analizar directorios y contar líneas de código, comentarios y líneas en blanco en diferentes lenguajes de programación.

  2. Filtrado y Objetivos: Exploraste cómo centrar tu análisis en tipos de archivos específicos utilizando --include-ext y cómo excluir directorios con --exclude-dir.

  3. Comparación e Informes: Aprendiste cómo comparar diferentes bases de código utilizando la opción --diff y cómo generar informes en varios formatos como CSV y XML.

  4. Análisis Avanzado: Descubriste opciones avanzadas que brindan información más detallada, como el seguimiento del progreso, la detección de archivos duplicados, la coincidencia de patrones y el análisis archivo por archivo.

CLOC es una herramienta poderosa para desarrolladores, gerentes de proyecto y auditores de código para cuantificar el tamaño y la complejidad de las bases de código. Al utilizar CLOC de manera efectiva, puedes:

  • Comprender la composición de tus proyectos
  • Seguir la productividad en la codificación
  • Estimar la complejidad del proyecto
  • Tomar decisiones informadas sobre la arquitectura y el mantenimiento del código
  • Generar informes para documentación y análisis

Estas capacidades hacen de CLOC una herramienta esencial en el conjunto de herramientas de cualquier desarrollador para el análisis de código y la gestión de proyectos.