Compter les lignes de code avec CLOC

LinuxLinuxBeginner
Pratiquer maintenant

💡 Ce tutoriel est traduit par l'IA à partir de la version anglaise. Pour voir la version originale, vous pouvez cliquer ici

Introduction

CLOC (Compter les lignes de code) est un outil en ligne de commande qui analyse les fichiers d'un répertoire et compte le nombre de lignes de code, de commentaires et de lignes vides dans une grande variété de langages de programmation. C'est une ressource inestimable pour les développeurs qui cherchent à comprendre la composition de leurs projets, mesurer leur productivité ou estimer la complexité d'un projet.

Interface de l'outil 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{{"Compter les lignes de code avec CLOC"}} linux/wget -.-> lab-273383{{"Compter les lignes de code avec CLOC"}} end

Comprendre CLOC et son utilisation de base

CLOC (Compter les lignes de code) est un outil puissant qui aide les développeurs à analyser leur base de code en comptant les lignes de code, les commentaires et les lignes vides dans plusieurs langages de programmation.

Dans cette étape, nous allons apprendre à utiliser CLOC avec sa syntaxe de base pour analyser un projet.

Commande de base de CLOC

La syntaxe de base pour utiliser CLOC est la suivante :

cloc [options] <file/directory>

Utilisons CLOC pour analyser le projet Flask qui a été cloné lors de la configuration :

  1. Ouvrez le terminal en cliquant sur l'icône du terminal dans la barre des tâches.
  2. Accédez au répertoire du projet Flask :
cd ~/project/flask
  1. Exécutez la commande de base de CLOC pour analyser l'ensemble du projet :
cloc .

Le . représente le répertoire actuel, donc cette commande demande à CLOC d'analyser tous les fichiers dans le répertoire actuel et ses sous-répertoires.

Comprendre la sortie

Après avoir exécuté la commande, CLOC affichera un tableau avec les informations suivantes :

  • Langage : Langages de programmation détectés dans le projet
  • Fichiers : Nombre de fichiers pour chaque langage
  • Vides : Nombre de lignes vides
  • Commentaires : Nombre de lignes de commentaires
  • Code : Nombre de lignes de code

La sortie devrait ressembler à ceci :

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

Cette sortie vous donne un aperçu complet de la composition de la base de code du projet Flask.

Analyser des types de fichiers spécifiques avec CLOC

CLOC vous permet d'analyser des types de fichiers spécifiques ou d'exclure certains fichiers de votre analyse. Cela est particulièrement utile lorsque vous travaillez sur de grands projets contenant plusieurs langages de programmation.

Analyser des extensions de fichiers spécifiques

Pour analyser uniquement les fichiers avec des extensions spécifiques, vous pouvez utiliser l'option --include-ext suivie d'une liste d'extensions de fichiers séparées par des virgules :

  1. Accédez au répertoire du projet Flask si vous n'y êtes pas déjà :
cd ~/project/flask
  1. Exécutez CLOC pour analyser uniquement les fichiers Python dans le projet :
cloc --include-ext=py .

La sortie affichera maintenant uniquement des informations sur les fichiers Python dans le projet :

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

Exclure des répertoires spécifiques

Vous pouvez également exclure des répertoires spécifiques de votre analyse en utilisant l'option --exclude-dir :

cloc --exclude-dir=tests .

Cette commande analyse le projet Flask mais exclut le répertoire tests. La sortie affichera les statistiques pour tous les fichiers du projet, sauf ceux du répertoire 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
--------------------------------------------------------------------------------

En utilisant ces options de filtrage, vous pouvez concentrer votre analyse sur les parties spécifiques de la base de code qui sont les plus pertinentes pour vos besoins.

Comparer des projets et générer des rapports

CLOC propose des fonctionnalités pour comparer différents projets et générer des rapports dans divers formats. Ces capacités sont particulièrement utiles pour suivre les modifications au fil du temps ou comparer différentes bases de code.

Comparer deux répertoires

Créons un simple projet à comparer avec Flask :

  1. Accédez au répertoire du projet :
cd ~/project
  1. Créez un nouveau répertoire pour un simple projet Python :
mkdir sample_project
cd sample_project
  1. Créez quelques fichiers Python avec du code :
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. Maintenant, comparons ce projet d'exemple avec le projet Flask en utilisant la fonctionnalité de comparaison (diff) de CLOC :
cd ~/project
cloc --diff flask sample_project

La sortie affichera la différence dans les métriques de code entre les deux projets :

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

Générer des rapports dans différents formats

CLOC peut générer des rapports dans divers formats, notamment CSV et XML. Créons un rapport CSV pour le projet Flask :

  1. Accédez au projet Flask :
cd ~/project/flask
  1. Générez un rapport CSV :
cloc --csv --out=flask_stats.csv .
  1. Affichez le contenu du rapport généré :
cat flask_stats.csv

Vous devriez voir l'analyse CLOC au format 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

Ce format CSV est particulièrement utile pour l'importation dans des tableurs ou d'autres outils d'analyse de données.

De même, vous pouvez générer un rapport XML :

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

Ces capacités de génération de rapports font de CLOC un outil polyvalent pour l'analyse de code et la gestion de projets.

Options avancées de CLOC pour une analyse détaillée

CLOC propose plusieurs options avancées pour une analyse plus détaillée et personnalisée. Ces options vous permettent d'obtenir des informations plus approfondies sur votre base de code.

Afficher la progression pendant l'analyse

Lors de l'analyse de grands projets, il est utile de voir la progression. Utilisez l'option --progress-rate pour afficher des mises à jour de progression :

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

Cette commande affichera une mise à jour de progression après chaque traitement de 10 fichiers.

Compter les fichiers dupliqués

CLOC peut identifier et signaler les fichiers dupliqués dans votre projet. Voyons comment utiliser cette fonctionnalité :

cloc --duplicate-threshold=15 .

L'option --duplicate-threshold définit le pourcentage minimal de code dupliqué requis pour que deux fichiers soient considérés comme dupliqués. Dans cet exemple, nous utilisons un seuil de 15 %, ce qui signifie que les fichiers qui partagent au moins 15 % de leur contenu seront signalés comme dupliqués.

Si des duplications sont trouvées, vous verrez une sortie qui inclut des informations sur les fichiers dupliqués :

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

Analyser les fichiers correspondant à un motif

Vous pouvez analyser les fichiers qui correspondent à un motif spécifique en utilisant l'option --match-f :

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

Cette commande compte le nombre de lignes de code uniquement dans les fichiers Python qui commencent par "test_". La sortie affichera les statistiques pour les fichiers de test dans le projet 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
-------------------------------------------------------------------------------

Cette fonctionnalité est particulièrement utile lorsque vous souhaitez vous concentrer sur des motifs de fichiers spécifiques dans un grand projet.

Afficher les résultats par fichier

Pour voir un détail de l'analyse par fichier individuel plutôt que simplement par langage, utilisez l'option --by-file :

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

Cette commande analyse les fichiers Python dans le répertoire src et affiche les résultats pour chaque fichier individuellement :

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

Cette vue détaillée vous aide à identifier quels fichiers spécifiques contribuent le plus à la taille de votre base de code.

Ces options avancées font de CLOC un outil polyvalent pour une analyse complète du code dans diverses situations.

Résumé

Dans ce laboratoire, vous avez appris à utiliser CLOC (Count Lines of Code - Compter les lignes de code) pour analyser des bases de code et obtenir des informations précieuses sur la composition des projets. Voici un résumé de ce que vous avez accompli :

  1. Utilisation de base : Vous avez appris à utiliser la commande de base cloc pour analyser des répertoires et compter le nombre de lignes de code, de commentaires et de lignes vides dans différents langages de programmation.

  2. Filtrage et ciblage : Vous avez exploré comment concentrer votre analyse sur des types de fichiers spécifiques en utilisant --include-ext et comment exclure des répertoires avec --exclude-dir.

  3. Comparaison et génération de rapports : Vous avez appris à comparer différentes bases de code en utilisant l'option --diff et à générer des rapports dans divers formats tels que CSV et XML.

  4. Analyse avancée : Vous avez découvert des options avancées qui fournissent des informations plus détaillées, telles que le suivi de la progression, la détection de fichiers dupliqués, la correspondance de motifs et l'analyse fichier par fichier.

CLOC est un outil puissant pour les développeurs, les gestionnaires de projet et les auditeurs de code afin de quantifier la taille et la complexité des bases de code. En utilisant efficacement CLOC, vous pouvez :

  • Comprendre la composition de vos projets
  • Suivre la productivité de codage
  • Estimer la complexité du projet
  • Prendre des décisions éclairées concernant l'architecture et la maintenance du code
  • Générer des rapports pour la documentation et l'analyse

Ces capacités font de CLOC un outil essentiel dans la boîte à outils de tout développeur pour l'analyse de code et la gestion de projet.