Подсчет строк кода с помощью CLOC

LinuxLinuxBeginner
Практиковаться сейчас

💡 Этот учебник переведен с английского с помощью ИИ. Чтобы просмотреть оригинал, вы можете перейти на английский оригинал

Введение

CLOC (Count Lines of Code, подсчет строк кода) — это инструмент командной строки, который анализирует файлы в каталоге и подсчитывает количество строк кода, комментариев и пустых строк на различных языках программирования. Это бесценный ресурс для разработчиков, которые стремятся понять состав своих проектов, измерить производительность или оценить сложность проекта.

Интерфейс инструмента 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{{"Подсчет строк кода с помощью CLOC"}} linux/wget -.-> lab-273383{{"Подсчет строк кода с помощью CLOC"}} end

Понимание CLOC и его базового использования

CLOC (Count Lines of Code, подсчет строк кода) — это мощный инструмент, который помогает разработчикам анализировать свой код, подсчитывая количество строк кода, комментариев и пустых строк на различных языках программирования.

На этом этапе мы узнаем, как использовать CLOC с базовым синтаксисом для анализа проекта.

Базовая команда CLOC

Базовый синтаксис использования CLOC выглядит следующим образом:

cloc [options] <file/directory>

Давайте используем CLOC для анализа проекта Flask, который был склонирован на этапе настройки:

  1. Откройте терминал, нажав на иконку терминала в панели задач.
  2. Перейдите в каталог проекта Flask:
cd ~/project/flask
  1. Запустите базовую команду CLOC для анализа всего проекта:
cloc .

Точка . представляет текущий каталог, поэтому эта команда сообщает CLOC анализировать все файлы в текущем каталоге и его подкаталогах.

Понимание вывода

После выполнения команды CLOC отобразит таблицу с следующей информацией:

  • Язык: Языки программирования, обнаруженные в проекте.
  • Файлы: Количество файлов на каждый язык.
  • Пустые: Количество пустых строк.
  • Комментарии: Количество строк комментариев.
  • Код: Количество строк кода.

Вывод должен выглядеть приблизительно так:

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

Этот вывод дает вам полное представление о составе кода проекта Flask.

Анализ определенных типов файлов с помощью CLOC

CLOC позволяет вам анализировать определенные типы файлов или исключать определенные файлы из анализа. Это особенно полезно при работе с большими проектами, содержащими несколько языков программирования.

Анализ файлов с определенными расширениями

Для анализа только файлов с определенными расширениями вы можете использовать опцию --include-ext, за которой следует список расширений файлов, разделенных запятыми:

  1. Перейдите в каталог проекта Flask, если вы еще не находитесь в нем:
cd ~/project/flask
  1. Запустите CLOC для анализа только Python-файлов в проекте:
cloc --include-ext=py .

Теперь вывод будет показывать только информацию о Python-файлах в проекте:

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

Исключение определенных каталогов

Вы также можете исключить определенные каталоги из анализа, используя опцию --exclude-dir:

cloc --exclude-dir=tests .

Эта команда анализирует проект Flask, но исключает каталог tests. Вывод будет показывать статистику для всех файлов проекта, кроме тех, которые находятся в каталоге 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
--------------------------------------------------------------------------------

Используя эти опции фильтрации, вы можете сосредоточить свой анализ на определенных частях кода, которые наиболее важны для ваших нужд.

Сравнение проектов и создание отчетов

CLOC предоставляет возможности для сравнения различных проектов и создания отчетов в различных форматах. Эти функции особенно полезны для отслеживания изменений во времени или сравнения разных кодовых баз.

Сравнение двух каталогов

Давайте создадим простой проект для сравнения с проектом Flask:

  1. Перейдите в каталог проекта:
cd ~/project
  1. Создайте новый каталог для простого Python-проекта:
mkdir sample_project
cd sample_project
  1. Создайте несколько Python-файлов с некоторым кодом:
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. Теперь сравним этот пример проекта с проектом Flask, используя функцию сравнения (diff) CLOC:
cd ~/project
cloc --diff flask sample_project

Вывод будет показывать разницу в показателях кода между двумя проектами:

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

Создание отчетов в разных форматах

CLOC может создавать отчеты в различных форматах, включая CSV и XML. Давайте создадим CSV-отчет для проекта Flask:

  1. Перейдите в каталог проекта Flask:
cd ~/project/flask
  1. Создайте CSV-отчет:
cloc --csv --out=flask_stats.csv .
  1. Просмотрите содержимое созданного отчета:
cat flask_stats.csv

Вы должны увидеть анализ CLOC в формате 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

Этот формат CSV особенно полезен для импорта в электронные таблицы или другие инструменты анализа данных.

Аналогично, вы можете создать XML-отчет:

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

Эти возможности по созданию отчетов делают CLOC универсальным инструментом для анализа кода и управления проектами.

Продвинутые опции CLOC для детального анализа

CLOC предлагает несколько продвинутых опций для более детального и настраиваемого анализа. Эти опции позволяют получить более глубокое понимание вашей кодовой базы.

Отображение прогресса во время анализа

При анализе больших проектов полезно видеть прогресс. Используйте опцию --progress-rate для отображения обновлений прогресса:

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

Эта команда будет отображать обновление прогресса после обработки каждых 10 файлов.

Подсчет дубликатов файлов

CLOC может определить и отчет о дубликатах файлов в вашем проекте. Давайте посмотрим, как использовать эту функцию:

cloc --duplicate-threshold=15 .

Опция --duplicate-threshold устанавливает минимальный процент дублирующего кода, при котором два файла будут считаться дубликатами. В этом примере мы используем порог в 15%, то есть файлы, которые имеют общий контент не менее чем на 15%, будут отображены как дубликаты.

Если дубликаты найдены, вы увидите вывод, включающий информацию о дублирующихся файлах:

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

Анализ файлов, соответствующих шаблону

Вы можете анализировать файлы, соответствующие определенному шаблону, используя опцию --match-f:

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

Эта команда подсчитывает строки кода только в Python-файлах, которые начинаются с "test_". Вывод будет показывать статистику для тестовых файлов в проекте 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
-------------------------------------------------------------------------------

Эта функция особенно полезна, когда вы хотите сосредоточиться на определенных шаблонах файлов в большом проекте.

Отображение результатов по файлам

Для просмотра разбиения анализа по отдельным файлам, а не только по языкам, используйте опцию --by-file:

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

Эта команда анализирует Python-файлы в каталоге src и отображает результаты для каждого файла отдельно:

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

Этот детальный вид помогает вам определить, какие конкретные файлы вносят наибольший вклад в размер вашей кодовой базы.

Эти продвинутые опции делают CLOC универсальным инструментом для комплексного анализа кода в различных сценариях.

Резюме

В этом практическом занятии вы узнали, как использовать CLOC (Count Lines of Code, подсчет строк кода) для анализа кодовых баз и получения ценной информации о составе проекта. Вот краткое резюме того, что вы достигли:

  1. Базовое использование: Вы научились использовать базовую команду cloc для анализа каталогов и подсчета строк кода, комментариев и пустых строк на различных языках программирования.

  2. Фильтрация и целевое использование: Вы изучили, как сосредоточить анализ на определенных типах файлов с помощью опции --include-ext и как исключить каталоги с помощью опции --exclude-dir.

  3. Сравнение и отчетность: Вы узнали, как сравнивать разные кодовые базы с помощью опции --diff и как создавать отчеты в различных форматах, таких как CSV и XML.

  4. Продвинутый анализ: Вы обнаружили продвинутые опции, которые предоставляют более детальную информацию, такие как отслеживание прогресса, обнаружение дубликатов файлов, сопоставление шаблонов и анализ по отдельным файлам.

CLOC - это мощный инструмент для разработчиков, менеджеров проектов и аудиторов кода, позволяющий количественно оценить размер и сложность кодовых баз. Эффективное использование CLOC позволяет:

  • Понимать состав своих проектов
  • Отслеживать производительность программирования
  • Оценивать сложность проекта
  • Принимать обоснованные решения по архитектуре и поддержке кода
  • Создавать отчеты для документации и анализа

Эти возможности делают CLOC незаменимым инструментом в арсенале любого разработчика для анализа кода и управления проектами.