cloc
v2.02
Contar líneas de código
cloc cuenta líneas en blanco, líneas de comentarios y líneas físicas de código fuente en muchos lenguajes de programación.
Última versión: v2.02 (2 de agosto de 2024)
cloc se mudó a GitHub en septiembre de 2015 después de estar alojado en http://cloc.sourceforge.net/ desde agosto de 2006.
Paso 1: descargue cloc (varios métodos, consulte a continuación) o ejecute la imagen acoplable de cloc. El ejecutable de Windows no tiene requisitos. La versión fuente de cloc requiere un intérprete de Perl y la versión Docker de cloc requiere una instalación de Docker.
Paso 2: abra una terminal ( cmd.exe en Windows).
Paso 3: Invoca cloc para contar tus archivos fuente, directorios, archivos o confirmaciones de git. El nombre del ejecutable difiere dependiendo de si utiliza la versión fuente de desarrollo ( cloc ), la fuente de una versión publicada ( cloc-2.02.pl ) o un ejecutable de Windows ( cloc-2.02.exe ).
En esta página, cloc es el término genérico utilizado para referirse a cualquiera de estos.
Include Security tiene un vídeo de YouTube que muestra los pasos en acción.
un archivo
símbolo> cloc hola.c
1 archivo de texto.
1 archivo único.
0 archivos ignorados.
https://github.com/AlDanial/cloc v 1,65 T=0,04 s (28,3 archivos/s, 340,0 líneas/s)
-------------------------------------------------- -----------------------
Código de comentario en blanco de archivos de idioma
-------------------------------------------------- -----------------------
C 1 0 7 5
-------------------------------------------------- -----------------------
un directorio
símbolo> cloc gcc-5.2.0/gcc/c
16 archivos de texto.
15 archivos únicos.
3 archivos ignorados.
https://github.com/AlDanial/cloc v 1,65 T=0,23 s (57,1 archivos/s, 188914,0 líneas/s)
-------------------------------------------------- -----------------------
Código de comentario en blanco de archivos de idioma
-------------------------------------------------- -----------------------
C 10 4680 6621 30812
Encabezado C/C++ 3 99 286 496
-------------------------------------------------- -----------------------
SUMA: 13 4779 6907 31308
-------------------------------------------------- -----------------------
un archivo
Extraeremos el archivo zip fuente de cloc de GitHub y luego contaremos el contenido:
símbolo> wget https://github.com/AlDanial/cloc/archive/master.zip símbolo> cloc master.zip https://github.com/AlDanial/cloc v 1,65 T=0,07 s (26,8 archivos/s, 141370,3 líneas/s) -------------------------------------------------- ----------------------- Código de comentario en blanco de archivos de idioma -------------------------------------------------- ----------------------- Perla 2 725 1103 8713 -------------------------------------------------- ----------------------- SUMA: 2 725 1103 8713 -------------------------------------------------- -----------------------
un repositorio de git, usando una confirmación específica
Este ejemplo utiliza código de PuDB, un fantástico depurador de Python.
símbolo> git clone https://github.com/inducer/pudb.git
símbolo> cd pudb
mensaje> reloj 6be804e07a5db
48 archivos de texto.
41 archivos únicos.
8 archivos ignorados.
github.com/AlDanial/cloc v 1,99 T=0,04 s (1054,9 archivos/s, 189646,8 líneas/s)
-------------------------------------------------- -----------------------
Código de comentario en blanco de archivos de idioma
-------------------------------------------------- -----------------------
Pitón 28 1519 728 4659
Texto reestructurado 6 102 20 203
YAML 2 9 2 75
Bourne Shell 3 6 0 17
Texto 1 0 0 11
hacer 1 4 6 10
-------------------------------------------------- -----------------------
SUMA: 41 1640 756 4975
-------------------------------------------------- -----------------------
cada subdirectorio de un directorio en particular
Supongamos que tiene un directorio con tres proyectos diferentes administrados por git, Proyecto0, Proyecto1 y Proyecto2. Puede utilizar la capacidad de bucle de su shell para contar el código en cada uno. Este ejemplo usa bash (desplácese hacia abajo para ver el ejemplo de cmd.exe):
símbolo> para d en ./*/; hacer (cd "$d" && echo "$d" && cloc --vcs git); hecho
./Proyecto0/
7 archivos de texto.
7 archivos únicos.
1 archivo ignorado.
github.com/AlDanial/cloc v 1.71 T=0.02 s (390.2 archivos/s, 25687.6 líneas/s)
-------------------------------------------------- -----------------------
Código de comentario en blanco de archivos de idioma
-------------------------------------------------- -----------------------
D 4 61 32 251
Rebaja 1 9 0 38
hacer 1 0 0 4
-------------------------------------------------- -----------------------
SUMA: 6 70 32 293
-------------------------------------------------- -----------------------
./Proyecto1/
7 archivos de texto.
7 archivos únicos.
0 archivos ignorados.
github.com/AlDanial/cloc v 1.71 T=0.02 s (293.0 archivos/s, 52107.1 líneas/s)
-------------------------------------------------- -----------------------
Código de comentario en blanco de archivos de idioma
-------------------------------------------------- -----------------------
Ir 7 165 282 798
-------------------------------------------------- -----------------------
SUMA: 7 165 282 798
-------------------------------------------------- -----------------------
./Proyecto2/
49 archivos de texto.
47 archivos únicos.
13 archivos ignorados.
github.com/AlDanial/cloc v 1.71 T=0.10 s (399.5 archivos/s, 70409.4 líneas/s)
-------------------------------------------------- -----------------------
Código de comentario en blanco de archivos de idioma
-------------------------------------------------- -----------------------
Pitón 33 1226 1026 3017
C 4 327 337 888
Rebaja 1 11 0 28
YAML 1 0 2 12
-------------------------------------------------- -----------------------
SUMA: 39 1564 1365 3945
-------------------------------------------------- -----------------------
cada subdirectorio de un directorio particular (Windows/cmd.exe)
para /D %I en (.*) hacer cd %I && cloc --vcs git && cd ..
cloc cuenta líneas en blanco, líneas de comentarios y líneas físicas de código fuente en muchos lenguajes de programación. Dadas dos versiones de un código base, cloc puede calcular diferencias en líneas en blanco, comentarios y fuente. Está escrito completamente en Perl sin dependencias fuera de la distribución estándar de Perl v5.6 y superiores (el código de algunos módulos externos está integrado en cloc) y, por lo tanto, es bastante portátil. Se sabe que cloc se ejecuta en muchas versiones de Linux, FreeBSD, NetBSD, OpenBSD, macOS, AIX, HP-UX, Solaris, IRIX, z/OS y Windows. (Para ejecutar la versión fuente de Perl de cloc en Windows se necesita ActiveState Perl 5.6.1 o superior, Strawberry Perl, Subsistema de Windows para Linux, Cygwin, MobaXTerm con el complemento Perl instalado o un entorno y terminal mingw como los proporcionados por Git para Windows Alternativamente, se puede usar el binario de Windows de cloc generado con PAR::Packer para ejecutarlo en computadoras con Windows que no tienen Perl ni Cygwin).
Además de contar código en archivos de texto individuales, directorios y repositorios de git, cloc también puede contar código en archivos como .tar (incluidas las versiones comprimidas), .zip , Python wheel .whl , Jupyter notebook .ipynb y RPM de origen .rpm o .src (requiere rpm2cpio ) y archivos Debian .deb (requiere dpkg-deb ).
cloc contiene código de SLOCCount de David Wheeler, Regexp::Common del módulo Perl de Damian Conway y Abigail, Win32::Autoglob del módulo Perl de Sean M. Burke y Algorithm::Diff del módulo Perl de Tye McQueen. Los factores de escala de idioma se derivaron del sitio web de Mayes Consulting, LLC http://softwareestimator.com/IndustryData2.htm.
Los nuevos lanzamientos aparecen nominalmente cada seis meses.
docker run --rm -v $PWD :/tmp aldanial/clocdocker run --rm -v " / $( pwd -W ) " :/tmp aldanial/clocDependiendo de su sistema operativo, uno de estos métodos de instalación puede funcionar para usted (todos excepto los dos últimos para Windows requieren un intérprete de Perl):
npm install -g cloc # https://www.npmjs.com/package/cloc
sudo apt install cloc # Debian, Ubuntu
sudo yum install cloc # Red Hat, Fedora
sudo dnf install cloc # Fedora 22 or later
sudo pacman -S cloc # Arch
sudo emerge -av dev-util/cloc # Gentoo https://packages.gentoo.org/packages/dev-util/cloc
sudo apk add cloc # Alpine Linux
doas pkg_add cloc # OpenBSD
sudo pkg install cloc # FreeBSD
sudo port install cloc # macOS with MacPorts
brew install cloc # macOS with Homebrew
winget install AlDanial.Cloc # Windows with winget
choco install cloc # Windows with Chocolatey
scoop install cloc # Windows with Scoop
Nota : No controlo ninguno de estos paquetes. Si encuentra un error en cloc al usar uno de los paquetes anteriores, intente con cloc extraído de la última versión estable aquí en GitHub (el enlace se encuentra a continuación) antes de enviar un informe de problema.
https://github.com/AlDanial/cloc/releases/latest
https://github.com/AlDanial/cloc/raw/master/cloc
cloc tiene la licencia GNU General Public License, v 2, excluyendo partes que se copian de otras fuentes. El código copiado de los módulos Regexp::Common, Win32::Autoglob y Algorithm::Diff Perl está sujeto a la licencia artística.
cloc tiene muchas características que lo hacen fácil de usar, completo, extensible y portátil:
Si cloc no se adapta a sus necesidades, aquí hay otros contadores disponibles gratuitamente que puede considerar:
Otras referencias:
Aunque cloc no necesita módulos Perl fuera de los que se encuentran en la distribución estándar, cloc sí depende de algunos módulos externos. El código de tres de estos módulos externos (Regexp::Common, Win32::Autoglob y Algorithm::Diff) está incrustado en cloc. Un cuarto módulo, Digest::MD5, se utiliza sólo si está disponible. Si cloc encuentra Regexp::Common o Algorithm::Diff instalado localmente, utilizará esa instalación. Si no es así, cloc instalará las partes de Regexp::Common y/o Algorithm:Diff que necesita en los directorios temporales que se crean al inicio de una ejecución de cloc y luego se eliminan cuando se completa la ejecución. El código necesario de Regexp::Common v2.120 y Algorithm::Diff v1.1902 está integrado en el código fuente de cloc (consulte las subrutinas Install_Regexp_Common() e Install_Algorithm_Diff() ). Sólo se necesitan tres líneas desde Win32::Autoglob y éstas se incluyen directamente en cloc.
Además, cloc utilizará Digest::MD5 para validar la unicidad entre archivos de entrada del mismo tamaño si Digest::MD5 está instalado localmente.
Se introdujo una opción de procesamiento paralelo, --processes= N , con la versión 1.76 de cloc para permitir ejecuciones más rápidas en máquinas multinúcleo. Sin embargo, para usarlo, es necesario tener instalado el módulo Parallel::ForkManager. Este módulo no funciona de manera confiable en Windows, por lo que el procesamiento paralelo solo funcionará en sistemas operativos tipo Unix.
El binario de Windows está integrado en una computadora que tiene Regexp::Common y Digest::MD5 instalados localmente.
La opción más sólida para crear un ejecutable de cloc en Windows es utilizar el kit de desarrollo Perl de ActiveState. Incluye una utilidad, perlapp , que puede crear binarios independientes de código fuente Perl para Windows, Mac y Linux.
perl2exe también funcionará. Si tiene perl2exe , modifique las líneas 84-87 en el código fuente de cloc para realizar una modificación menor del código que es necesaria para convertir un cloc en ejecutable de Windows.
De lo contrario, para crear un ejecutable de Windows con pp de PAR::Packer , primero instale una distribución Perl basada en Windows (por ejemplo, Strawberry Perl o ActivePerl) siguiendo sus instrucciones. A continuación, abra un símbolo del sistema, también conocido como ventana de DOS e instale el módulo PAR::Packer. Finalmente, invoque el comando pp recién instalado con el código fuente cloc para crear un archivo .exe :
C:> cpan -i Resumen::MD5 C:> cpan -i Regexp::Común C:> cpan -i Algoritmo::Diff C:> cpan -i PAR::Empaquetador C:> cpan -i Win32::LongPath C:> pp -M Win32::LongPath -M Codificación::Unicode -M Digest::MD5 -c -x -o cloc-2.02.exe cloc-2.02.pl
Una variación de las instrucciones anteriores es que si instaló la versión portátil de Strawberry Perl, primero deberá ejecutar portableshell.bat para configurar correctamente su entorno.
El ejecutable de Windows en la sección Lanzamientos, cloc-2.02.exe , se creó en una computadora con Windows 10 de 64 bits usando Strawberry Perl 5.30.2 y PAR::Packer para compilar el .exe .
Idealmente, nadie necesitaría el ejecutable de Windows porque tienen un intérprete de Perl instalado en sus máquinas y pueden ejecutar el archivo fuente cloc. Sin embargo, en máquinas Windows corporativas administradas centralmente, esto puede resultar difícil o imposible.
El ejecutable de Windows distribuido con cloc se proporciona como el mejor esfuerzo de un .exe libre de virus y malware. Le recomendamos que ejecute sus propios escáneres de virus contra el ejecutable y también consulte sitios como https://www.virustotal.com/. Las entradas para versiones recientes son:
cloc-2.02-winget.exe: (incluye PR 850 para permitir la ejecución desde un enlace simbólico en Windows) https://www.virustotal.com/gui/file/be033061e091fea48a5bc9e8964cee0416ddd5b34bd5226a1c9aa4b30bdba66a?nocache=1
cloc-2.02.exe: https://www.virustotal.com/gui/file/369ed76125f7399cd582d169adf39a2e08ae5066031fea0cc8b2836ea50e7ce2?nocache=1
cloc-2.00.exe: https://www.virustotal.com/gui/file/7a234ef0cb495de1b5776acf88c5554e2bab1fb02725a5fb85756a6db3121c1f
cloc-1.98.exe: https://www.virustotal.com/gui/file/88615d193ec8c06f7ceec3cc1d661088af997798d87ddff331d9e9f9128a6782?nocache=1
cloc-1.96.1.exe: https://www.virustotal.com/gui/file/00b1c9dbbfb920dabd374418e1b86d2c24b8cd2b8705aeb956dee910d0d75d45?nocache=1
cloc-1.96.exe: https://www.virustotal.com/gui/file/54bf5f46fbaba7949c4eb2d4837b03c774c0ba587448a5bad9b8efc0222b1583?nocache=1
cloc-1.94.exe: https://www.virustotal.com/gui/file/b48a6002fb75fa66ec5d0c05a5c4d51f2ad22b5b025b7eb4e3945d18419c0952?nocache=1
cloc-1.92.exe: https://www.virustotal.com/gui/file/2668fcf8609c431e8934fe9e1866bc620c58d198c4eb262f1d3ef31ef4a690f7
cloc-1.90.exe: https://www.virustotal.com/gui/file/d655caae55486f9bac39f7e3c7b7553bcfcfe2b88914c79bfc328055f22b8a37/detection
cloc-1.88.exe: https://www.virustotal.com/gui/file/97d5d2631d1cccdbfd99267ab8a4cf5968816bbe52c0f9324e72e768857f642d/detection
cloc-1.86.exe: https://www.virustotal.com/gui/file/1b2e189df1834411b34534db446330d1c379b4bc008af3042ee9ade818c6a1c8/detection
cloc-1.84.exe: https://www.virustotal.com/gui/file/e73d490c1e4ae2f50ee174005614029b4fa2610dcb76988714839d7be68479af/detection
cloc-1.82.exe: https://www.virustotal.com/#/file/2e5fb443fdefd776d7b6b136a25e5ee2048991e735042897dbd0bf92efb16563/detection
cloc-1.80.exe: https://www.virustotal.com/#/file/9e547b01c946aa818ffad43b9ebaf05d3da08ed6ca876ef2b6847be3bf1cf8be/detection
cloc-1.78.exe: https://www.virustotal.com/#/file/256ade3df82fa92febf2553853ed1106d96c604794606e86efd00d55664dd44f/detection
cloc-1.76.exe: https://www.virustotal.com/#/url/c1b9b9fe909f91429f95d41e9a9928ab7c58b21351b3acd4249def2a61acd39d/detection
cloc-1.74_x86.exe: https://www.virustotal.com/#/file/b73dece71f6d3199d90d55db53a588e1393c8dbf84231a7e1be2ce3c5a0ec75b/detection
cloc 1.72 exe: https://www.virustotal.com/en/url/8fd2af5cd972f648d7a2d7917bc202492012484c3a6f0b48c8fd60a8d395c98c/analysis/
cloc 1.70 exe: https://www.virustotal.com/en/url/63edef209099a93aa0be1a220dc7c4c7ed045064d801e6d5daa84ee624fc0b4a/analysis/
cloc 1.68 exe: https://www.virustotal.com/en/file/c484fc58615fc3b0d5569b9063ec1532980281c3155e4a19099b11ef1c24443b/analysis/
cloc 1.66 exe: https://www.virustotal.com/en/file/54d6662e59b04be793dd10fa5e5edf7747cf0c0cc32f71eb67a3cf8e7a171d81/analysis/1453601367/
Los ejecutables de Windows de las versiones 1.60 y anteriores de cloc, creados con perl2exe como se indicó anteriormente, pesan aproximadamente 1,6 MB, mientras que las versiones 1.62 y 1.54, creadas con PAR::Packer , pesan 11 MB. La versión 1.66, creada con una versión más reciente de PAR::Packer , ocupa aproximadamente 5,5 MB. ¿Por qué los ejecutables PAR::Packer son mucho más grandes que los creados con perl2exe? Mi teoría es que perl2exe utiliza una lógica de poda de árboles más inteligente que PAR::Packer , pero eso es pura especulación.
cloc es un programa de línea de comandos que toma nombres de archivos, directorios y/o archivos comprimidos como entradas. A continuación se muestra un ejemplo de ejecución de cloc en la distribución fuente de Perl v5.22.0:
símbolo> cloc perl-5.22.0.tar.gz
5605 archivos de texto.
5386 archivos únicos.
2176 archivos ignorados.
https://github.com/AlDanial/cloc v 1,65 T=25,49 s (134,7 archivos/s, 51980,3 líneas/s)
-------------------------------------------------- ---------------------------------
Código de comentario en blanco de archivos de idioma
-------------------------------------------------- ---------------------------------
Perl2892 136396 184362 536445
C 130 24676 33684 155648
Encabezado C/C++ 148 9766 16569 147858
Bourne Shell 112 4044 6796 42668
Pascual 8 458 1603 8592
XML 33 142 0 2410
YAML 49 20 15 2078
C++ 10 313 277 2033
hacer 4 426 488 1986
Prólogo 12 438 2 1146
JSON14 1 0 1037
yacc 1 85 76 998
Archivo de mensajes de Windows 1 102 11 489
Lote DOS 14 92 41 389
Archivo de recursos de Windows 3 10 0 85
D 1 5 7 8
Ceceo 2 0 3 4
-------------------------------------------------- ---------------------------------
SUMA: 3434 176974 243934 903874
-------------------------------------------------- ---------------------------------
Para ejecutar cloc en computadoras con Windows, abra una ventana de comando (también conocida como DOS) e invoque cloc.exe desde la línea de comando allí. Alternativamente, pruebe ClocViewer, el contenedor GUI de cloc que se encuentra en https://github.com/Roemer/ClocViewer.
Consulte también https://github.com/jmensch1/codeflower para obtener una representación gráfica de los resultados de cloc.
símbolo> cloc --ayuda
Uso: cloc [opciones] <archivo(s)/dir(es)/git hash(es)> | <conjunto 1> <conjunto 2> | <archivos de informe>
Contar o calcular diferencias de líneas físicas de código fuente en el
archivos dados (pueden ser archivos como archivos tar comprimidos o archivos zip,
o git commit hashes o nombres de ramas) y/o recursivamente debajo del
directorios dados.
Opciones de entrada
--extract-with=<cmd> Esta opción solo es necesaria si cloc no puede
para descubrir cómo extraer el contenido de
los archivos de entrada por sí solo.
Utilice <cmd> para extraer archivos binarios (por ejemplo:
.tar.gz, .zip, .Z). Utilice el literal '>FILE<' como
un sustituto para los archivos reales que se van a
extraído. Por ejemplo, para contar líneas de código.
en los archivos de entrada
gcc-4.2.tar.gz perl-5.8.8.tar.gz
sobre el uso de Unix
--extract-with='gzip -dc >ARCHIVO< | alquitrán xf -'
o, si tienes GNU tar,
--extract-with='tar zxf >ARCHIVO<'
y en uso de Windows, por ejemplo:
--extract-with=""c:Program FilesWinZipWinZip32.exe" -e -o >ARCHIVO< ."
(si WinZip está instalado allí).
--list-file=<archivo> Lleva la lista de nombres de archivos y/o directorios a
proceso desde <archivo>, que tiene un archivo/directorio
nombre por línea. Sólo se cuentan las coincidencias exactas;
Los nombres de ruta relativos se resolverán a partir de
el directorio donde se invoca cloc. Establecer <archivo>
a - para leer nombres de archivos desde una tubería STDIN.
Consulte también --exclude-list-file.
--diff-list-file=<archivo> Tome los pares de nombres de archivos de los que se va a diferenciar
<archivo>, cuyo formato coincide con la salida de
--alineación diferencial. (Ejecute con esa opción para
ver un ejemplo.) El identificador de idioma en el
Se ignora el final de cada línea. Esto habilita --diff
modo y omite la lógica de alineación de pares de archivos.
--vcs=<VCS> Invoca una llamada al sistema a <VCS> para obtener una lista de
archivos para trabajar. Si <VCS> es 'git', entonces
invoca 'git ls-files' para obtener una lista de archivos y
'git submodule status' para obtener una lista de submódulos
cuyo contenido será ignorado. Ver también --git
que acepta hashes de confirmación de git y nombres de ramas.
Si <VCS> es 'svn', invocará 'svn list -R'.
El principal beneficio es que cloc se saltará
archivos excluidos explícitamente por la herramienta de control de versiones
en cuestión, es decir, aquellos en .gitignore o tienen la
svn: ignorar la propiedad.
Alternativamente, <VCS> puede ser cualquier comando del sistema.
que genera una lista de archivos.
Nota: cloc debe estar en un directorio que pueda leer
los archivos tal como los devuelve <VCS>. cloc voluntad
No descargar archivos de repositorios remotos.
'svn list -R' puede hacer referencia a un repositorio remoto
para obtener nombres de archivos (y por lo tanto puede requerir
autenticación en el repositorio remoto), pero
los archivos en sí deben ser locales.
Configurar <VCS> en 'auto' selecciona entre 'git'
y 'svn' (o ninguno) dependiendo de la presencia
de un subdirectorio .git o .svn debajo del directorio
donde se invoca cloc.
--unicode Comprueba los archivos binarios para ver si contienen Unicode
texto ASCII ampliado. Esto hace que el rendimiento
bajar notablemente.
Opciones de procesamiento
--autoconf Contar archivos .in (procesados por GNU autoconf) de
lenguas reconocidas. Véase también --no-autogen.
--by-file Informa los resultados de cada archivo fuente encontrado.
--by-file-by-lang Informar los resultados de cada archivo fuente encontrado
además de informar por idioma.
--config <archivo> Leer la línea de comando cambia desde <archivo> en lugar de
la ubicación predeterminada de /home/al/.config/cloc/options.txt.
El archivo debe contener un modificador, junto con
argumentos (si los hay), por línea. Líneas y líneas en blanco.
que comienzan con '#' se omiten. Opciones dadas en
la línea de comando tiene prioridad sobre las entradas leídas desde
el archivo.
--count-and-diff <conjunto1> <conjunto2>
Primero realice recuentos de código directo de los archivos fuente
de <set1> y <set2> por separado, luego realice una diferenciación
de estos. Las entradas pueden ser pares de archivos, directorios,
o archivos. Si se proporciona --out o --report-file,
Se crearán tres archivos de salida, uno para cada
de los dos conteos y uno para la diferencia. Ver también
--diff, --diff-alignment, --diff-timeout,
--ignore-case, --ignore-whitespace.
--diff <set1> <set2> Calcula las diferencias en el código y los comentarios entre
archivo(s) fuente de <set1> y <set2>. las entradas
puede ser cualquier combinación de archivos, directorios, archivos,
o git commit hashes. Utilice --diff-alignment para
generar una lista que muestre qué pares de archivos dónde
comparado. Al comparar ramas de git, solo archivos
Se comparan los que han cambiado en cualquiera de las confirmaciones.
Véase también --git, --count-and-diff, --diff-alignment,
--diff-list-file, --diff-timeout, --ignore-case,
--ignorar-espacios en blanco.
--diff-timeout <N> Ignora archivos que tardan más de <N> segundos
para procesar. El valor predeterminado es 10 segundos. Configuración <N>
a 0 permite tiempo ilimitado. (Archivos grandes con muchos
las líneas repetidas pueden causar Algoritmo::Diff::sdiff()
tomar horas.) Consulte también --timeout.
--docstring-as-code cloc considera que las cadenas de documentos son comentarios, pero esto es
no siempre es correcto ya que las cadenas de documentos representan regulares
cadenas cuando aparecen en el lado derecho de una
asignación o como argumentos de función. Este interruptor
obliga a que las cadenas de documentos se cuenten como código.
--follow-links [solo Unix] Sigue enlaces simbólicos a directorios
(Siempre se siguen los enlaces simbólicos a los archivos).
Véase también --stat.
--force-lang=<idioma>[,<ext>]
Procesar todos los archivos que tengan una extensión <ext>
con el contador del idioma <lang>. Para
Por ejemplo, para contar todos los archivos .f con el
Contador Fortran 90 (que espera que los archivos
terminar con .f90) en lugar del Fortran 77 predeterminado
contador, uso
--force-lang="Fortran 90,f"
Si se omite <ext>, se contarán todos los archivos
con el contador <lang>. Esta opción puede ser
especificado varias veces (pero eso es sólo
útil cuando se proporciona <ext> cada vez).
Véase también --script-lang, --lang-no-ext.
--force-lang-def=<archivo> Cargar filtros de procesamiento de lenguaje desde <archivo>,
luego use estos filtros en lugar de los incorporados
filtros. Nota: idiomas que se asignan al mismo
extensión de archivo (por ejemplo:
MATLAB/Mathematica/Objective-C/MUMPS/Mercurio;
Pascal/PHP; Lisp/OpenCL; Ceceo/Julia; Perl/Prólogo)
serán ignorados ya que requieren
procesamiento que no se expresa en el lenguaje
archivos de definición. Utilice --read-lang-def para definir
Nuevos filtros de idioma sin reemplazar los incorporados.
filtros (ver también --write-lang-def,
--write-lang-def-incl-dup).
--git Fuerza que las entradas se interpreten como objetivos de git
(confirmar hashes, nombres de ramas, etcétera) si estos
no se identifican primero como archivo o directorio
nombres. Esta opción anula la lógica --vcs=git
si esto se da; en otras palabras, --git obtiene su
lista de archivos para trabajar directamente desde git usando
el hash o el nombre de la rama en lugar de desde
'git ls-files'. Esta opción se puede utilizar con
--diff para realizar diferencias de recuento de líneas entre git
confirmaciones, o entre una confirmación de git y un archivo,
directorio o archivo. Utilice -v/--verbose para ver
el sistema git controla los problemas de cloc.
--git-diff-rel Igual que --git --diff, o simplemente --diff si las entradas
son reconocidos como objetivos de git. Sólo archivos que
han cambiado en cualquiera de las confirmaciones.
--git-diff-all Estrategia de diferenciación de Git n.° 2: comparar todos los archivos en el
repositorio entre las dos confirmaciones.
--ignore-whitespace Ignora los espacios en blanco horizontales al comparar archivos
con --diff. Véase también --ignore-case.
--ignore-case Ignora los cambios en mayúsculas y minúsculas dentro del contenido del archivo;
considere equivalentes las letras mayúsculas y minúsculas
al comparar archivos con --diff. Ver también
--ignorar-espacios en blanco.
--ignore-case-ext Ignora mayúsculas y minúsculas en las extensiones de nombre de archivo. esto será
causar problemas para contar algunos idiomas
(específicamente, .c y .C están asociados con C y
C++; este cambio contaría los archivos .C como C en lugar
que C++ en sistemas operativos *nix). Nombre del archivo
La insensibilidad a mayúsculas y minúsculas siempre es cierta en Windows.
--lang-no-ext=<idioma> Cuente archivos sin extensiones usando <idioma>
encimera. Esta opción anula la lógica interna.
para archivos sin extensiones (cuando dichos archivos
se comparan con lenguajes de secuencias de comandos conocidos
examinando la primera línea para #!). Ver también
--force-lang, --script-lang.
--max-file-size=<MB> Omitir archivos de más de <MB> megabytes cuando
atravesando directorios. De forma predeterminada, <MB>=100.
El requisito de memoria de cloc es aproximadamente veinte veces mayor.
más grande que el archivo más grande, por lo que se ejecuta con
archivos de más de 100 MB en una computadora con menos
Más de 2 GB de memoria causarán problemas.
Nota: esta verificación no se aplica a los archivos.
pasado explícitamente como argumentos de línea de comando.
--no-autogen[=list] Ignorar archivos generados por sistemas de producción de código
como GNU autoconf. Para ver una lista de estos archivos
(luego salga), ejecute con la lista --no-autogen
Véase también --autoconf.
--original-dir [Solo efectivo en combinación con
--strip-comments] Escribe los archivos eliminados
al mismo directorio que los archivos originales.
--read-binary-files Procesa archivos binarios además de archivos de texto.
Esto suele ser una mala idea y sólo debería
intentado con archivos de texto que tienen incrustados
datos binarios.
--read-lang-def=<archivo> Cargar nuevos filtros de procesamiento de lenguaje desde <archivo>
y fusionarlos con los que ya se sabe que cloc.
Si <archivo> define un idioma, cloc ya lo sabe
Al respecto, la definición de cloc tendrá prioridad.
Utilice --force-lang-def para anular los relojes
definiciones (ver también --write-lang-def,
--write-lang-def-incl-dup).
--script-lang=<lang>,<s> ¡Procesa todos los archivos que invocan <s> como #!
lenguaje de scripting con el contador de lenguaje
<idioma>. Por ejemplo, archivos que comienzan con
#!/usr/local/bin/perl5.8.8
se contará con el contador de Perl utilizando
--script-lang=Perl,perl5.8.8
El nombre del idioma no distingue entre mayúsculas y minúsculas, pero el
nombre del ejecutable del lenguaje de script, <s>,
debe tener el caso correcto. Esta opción puede ser
especificado varias veces. Véase también --force-lang,
--lang-no-ext.
--sdir=<dir> Utilice <dir> como directorio temporal en lugar de
dejando que File::Temp elija la ubicación. Archivos
escritos en esta ubicación no se eliminan en
al final de la ejecución (como ocurre con File::Temp).
--skip-uniqueness Omite la comprobación de unicidad del archivo. esto le dará
un aumento del rendimiento a expensas del conteo
archivos con contenido idéntico varias veces
(si existen dichos duplicados).
--stat Algunos sistemas de archivos (AFS, CD-ROM, FAT, HPFS, SMB)
no tiene recuentos de directorio 'nlink' que coincidan
el número de sus subdirectorios. Como consecuencia
cloc puede subestimar o omitir por completo el
contenidos de dichos sistemas de archivos. Este interruptor fuerza
Archivo::Buscar directorios estadísticos para obtener el
recuento correcto. La velocidad de búsqueda de archivos disminuirá.
Ver también --follow-links.
--stdin-name=<archivo> Proporcione un nombre de archivo para determinar el idioma
para entrada estándar. (Utilice - como nombre de entrada para
recibir el código fuente a través de STDIN.)
--strip-comments=<ext> Para cada archivo procesado, escriba en el actual
directorio una versión del archivo que tiene en blanco
y líneas comentadas eliminadas (comentarios en línea
persistir). El nombre de cada archivo eliminado es el
nombre de archivo original con .<ext> añadido.
Se escribe en el directorio actual a menos que
--original-dir está activado.
--strip-str-comments Reemplazar marcadores de comentarios incrustados en cadenas con
'xx'. Esto intenta solucionar una limitación.
en Regexp::Common::Comentario donde los marcadores de comentarios
incrustados en cadenas se ven como comentarios reales
marcadores y no cadenas, lo que a menudo resulta en una
'Límite de recursividad de subexpresiones regulares complejas'
Advertencias y recuentos incorrectos. hay dos
desventajas de usar este interruptor: 1/recuento de códigos
caídas de rendimiento y 2/código generado con
--strip-comments contendrá cadenas diferentes
donde se encuentran los comentarios incrustados.
--sum-reports Los argumentos de entrada son archivos de informes anteriores
creado con la opción --report-file en formato simple
formato (por ejemplo, no JSON, YAML, XML o SQL).
Crea un conjunto acumulativo de resultados que contienen
suma de datos de los archivos de informes individuales.
--timeout <N> Ignora archivos que tardan más de <N> segundos
para procesar en cualquiera de las etapas de filtrado del idioma.
El número máximo predeterminado de segundos dedicados a una
la etapa de filtro es el número de líneas en el archivo
dividido por mil. Establecer <N> en 0 permite
tiempo ilimitado. Consulte también --diff-timeout.
--processes=NUM [Disponible solo en sistemas con una versión reciente
del módulo Parallel::ForkManager. No
disponible en Windows.] Establece el número máximo de
núcleos que utiliza cloc. El valor predeterminado de 0
desactiva el multiprocesamiento.
--unix Anula la detección automática del sistema operativo
lógica y ejecutarse en modo UNIX. Ver también
--ventanas, --show-os.
--use-sloccount Si SLOCCount está instalado, use su compilado
ejecutables c_count, java_count, pascal_count,
php_count y xml_count en lugar de cloc
contadores. Los contadores compilados de SLOCCount son
sustancialmente más rápido que el de cloc y puede dar
una mejora del rendimiento al contar proyectos
con archivos grandes. Sin embargo, estos relojes específicos
las funciones no estarán disponibles: --diff,
--count-and-diff, --strip-comments, --unicode.
--windows Anula la detección automática del sistema operativo
lógica y ejecutar en modo Microsoft Windows.
Véase también --unix, --show-os.
Opciones de filtro
--include-content=<regex> Solo cuenta los archivos que contienen texto que coincide con el
expresión regular dada.
--exclude-content=<regex> Excluir archivos que contengan texto que coincida con el especificado
expresión regular.
--exclude-dir=<D1>[,D2,] Excluir los directorios separados por comas proporcionados
D1, D2, D3, etcétera, de ser escaneados. Para
ejemplo --exclude-dir=.cache, la prueba se omitirá
todos los archivos y subdirectorios que tienen /.cache/
o /test/ como su directorio principal.
Directorios denominados .bzr, .cvs, .hg, .git, .svn,
y .snapshot siempre están excluidos.
Esta opción solo funciona con directorio individual.
nombres, por lo que incluir separadores de ruta de archivo no es
permitido. Utilice --fullpath y --not-match-d=<regex>
para proporcionar una expresión regular que coincida con varios subdirectorios.
--exclude-ext=<ext1>[,<ext2>[...]]
No cuente los archivos que tengan el nombre de archivo indicado
extensiones.
--exclude-lang=<L1>[,L2[...]]
Excluir los idiomas separados por comas
L1, L2, L3, etcétera, para que no se cuenten.
--exclude-list-file=<archivo> Ignora archivos y/o directorios cuyos nombres
aparecer en <archivo>. <archivo> debe tener un archivo
nombre por línea. Sólo se ignoran las coincidencias exactas;
Los nombres de ruta relativos se resolverán a partir de
el directorio donde se invoca cloc.
Véase también --list-file.
--fullpath Modifica el comportamiento de --match-f, --not-match-f,
y --not-match-d para incluir la ruta del archivo
en la expresión regular, no solo el nombre base del archivo.
(Esto no expande cada archivo para incluir su
ruta absoluta, en su lugar utiliza la mayor cantidad de
el camino cuando se pasa a cloc.)
Nota: --match-d siempre mira el archivo completo
ruta y por lo tanto no se ve afectada por --fullpath.
--include-ext=<ext1>[,ext2[...]]
Cuente solo los idiomas que tengan la coma dada
extensiones de archivos separadas. Utilice --show-ext para
ver las extensiones reconocidas.
--include-lang=<L1>[,L2[...]]
Cuente solo los idiomas separados por comas
L1, L2, L3, etcétera. Utilice --show-lang para ver
la lista de idiomas reconocidos.
--match-d=<regex> Solo cuenta archivos en directorios que coincidan con Perl
expresión regular. Por ejemplo
--match-d='/(src|incluir)/'
sólo cuenta archivos en directorios que contienen
/src/ o /include/. A diferencia de --not-match-d,
--match-f y --not-match-f, --match-d siempre
compara la ruta totalmente calificada con la
expresión regular.
--not-match-d=<regex> Cuente todos los archivos excepto los de los directorios
que coincide con la expresión regular de Perl. Sólo el final
El nombre del directorio se compara, por ejemplo, cuando
contando en /usr/local/lib, sólo 'lib' es
en comparación con la expresión regular.
Agregue --fullpath para comparar los directorios principales con
la expresión regular.
No incluya separadores de ruta de archivo en el
principio o final de la expresión regular.
--match-f=<regex> Solo cuenta los archivos cuyos nombres base coincidan con Perl
expresión regular. Por ejemplo
--match-f='^[Ww]idget'
sólo cuenta los archivos que comienzan con Widget o widget.
Agregue --fullpath para incluir directorios principales
en la expresión regular en lugar de solo el nombre base.
--not-match-f=<regex> Cuente todos los archivos excepto aquellos cuyos nombres base
coincide con la expresión regular de Perl. Agregue --fullpath para incluir
directorios principales en la expresión regular en lugar de simplemente
el nombre base.
--skip-archive=<regex> Ignorar archivos que terminan con el Perl regular dado
expresión. Por ejemplo, si se le da
--skip-archive='(zip|tar(.(gz|Z|bz2|xz|7z))?)'
el código omitirá los archivos que terminen en .zip,
.tar, .tar.gz, .tar.Z, .tar.bz2, .tar.xz y
.tar.7z.
--skip-win-hidden En Windows, ignora los archivos ocultos.
Opciones de depuración
--categorized=<archivo> Guardar tamaños de archivos en bytes, idiomas identificados
y nombres de archivos categorizados a <chile>.
--contado = <sche> Guardar nombres de los archivos de origen procesados en <Sche>.
--Diff-Alignment = <Sche> Escribir en <Sche> Una lista de archivos y pares de archivos
mostrando qué archivos se agregaron, eliminaron y/o
comparado durante una carrera con --diff. Este interruptor
Fuerza el modo --diff.
--explane = <lang> Imprima los filtros utilizados para eliminar los comentarios para
Lenguaje <Lang> y salida. En algunos casos el
Los filtros se refieren a las subrutinas de Perl en lugar de
Expresiones regulares. Un examen de la
El código fuente puede ser necesario para una explicación adicional.
-Help Imprime esta información y salida de uso.
--found = <sche> Guardar nombres de cada archivo encontrado en <Sche>.
--ignored = <chile> Guardar nombres de archivos ignorados y la razón por la que
fueron ignorados a <sche>.
-Código fuente procesado de impresión de filtros de huella de impresión
Se aplica cada filtro.
--show-ext [= <ttt>] Imprimir información sobre todos los conocidos (o solo el
Dado) Extensiones de archivo y salida.
--show-lang [= <lang>] Imprima información sobre todos los conocidos (o solo el
dado) Idiomas y salida.
--show-os imprime el valor del modo del sistema operativo
y salir. Ver también --unix, -Windows.
-v [= <n>] interruptor de verbose (valor numérico opcional).
-verbose [= <n>] forma larga de -v.
-Versión Imprima la versión de este programa y salida.
--Write-Lang-Def = <Sche> escribe en <Sche> Los filtros de procesamiento del lenguaje
luego sale. Útil como primer paso para crear
Definiciones de lenguaje personalizados. Nota: Idiomas que
Se excluirá el mapa a la misma extensión del archivo.
(Ver también --force-lang-des, --read-lang-des).
--WRITE-LANG-DEF-INCL-DUP = <Sche>
Igual que--Write-Lang-Def, pero incluye duplicado
extensiones. Esto genera un lenguaje problemático
Archivo de definición porque CLOC se negará a usar
hasta que se eliminen los duplicados.
Opciones de salida
--3 Imprima la salida del idioma de tercera generación.
(Esta opción puede hacer que la suma de informes falle
Si se produjeron algunos informes con esta opción
mientras que otros fueron producidos sin él).
-Por el porcentaje x en lugar de comentarios y recuentos de línea en blanco, mostrar
Estos valores como porcentajes basados en el valor
de x en el denominador:
X = 'c' -> # líneas de código
X = 'cm' -> # líneas de código + comentarios
X = 'cb' -> # líneas de código + espacios en blanco
X = 'cmb' -> # líneas de código + comentarios + espacios en blanco
Por ejemplo, si se usa el método 'C' y su código
tiene el doble de líneas de comentarios que las líneas
de código, el valor en la columna de comentarios
ser 200%. La columna de código sigue siendo un recuento de líneas.
--CSV escribe los resultados como valores separados por comas.
--csv-delimiter = <c> use el carácter <c> como delimitador para la coma
archivos separados en lugar de ,. Este interruptor fuerza - -CSV para estar encendido.
--file-ending = <E> Escribir archivos de salida utilizando la codificación <E> en lugar de
El ASCII predeterminado (<E> = 'UTF-7'). Ejemplos: 'UTF-16',
'EUC-KR', 'ISO-8859-16'. Las codificaciones conocidas pueden ser
impreso con
perl -mencode -e 'print Join (" n", encode-> codings (": all")), " n"'
-Hide-thel no muestra tasas de procesamiento de línea y archivos en el
Encabezado de salida. Esto hace que la salida sea determinista.
--json escribe los resultados como notación de objeto JavaScript
(JSON) Salida formateada.
--MD Escriba los resultados como texto con formato de Markdown.
--out = <sche> sinónimo de --peport-file = <schil>.
--progress-rate = <n> Mostrar actualización de progreso después de cada <n> archivos son
procesado (predeterminado <n> = 100). Establecer <n> a 0 a
suprimir la salida de progreso (útil al redirigir
salida a stdout).
-Quite suprima todos los mensajes de información excepto para
El informe final.
--Preport-File = <Sche> Escriba los resultados en <Sche> en lugar de STDOUT.
--sql = <sche> Escribir resultados como SQL Crear e insertar declaraciones
que puede ser leído por un programa de base de datos como
Sqlite. If <archivo> es -, la salida se envía a stdout.
--sql-append append sql inserte las declaraciones en el archivo especificado
por --sql y no genere la creación de mesa
declaraciones. Solo válido con la opción --sql.
--sql-project = <name> use <name> como el identificador del proyecto para el
ejecución actual. Solo válido con la opción --sql.
--sql-style = <syle> escribir declaraciones SQL en el estilo dado
del formato SQLite predeterminado. Los estilos incluyen
'Oracle' y 'named_columns'.
--sum-one para informes de texto sin formato, muestre la suma: línea de salida
Incluso si solo se procesa un archivo de entrada.
--xml Escriba los resultados en XML.
--xsl = <chile> reference <Schil> como una hoja de estilo XSL dentro de
la salida XML. Si <Sche> es 1 (numérico),
escribe una hoja de estilo predeterminada, cloc.xsl (o
CLOC-DIFF.XSL IF--DIFF también se da).
Este interruptor Fuerza -xml encendido.
-yaml escriba los resultados en Yaml.
indicador> cloc --show-lang ABAP (ABAP) ActionScript (as) ADA (ADA, ADB, ADS, PAD) ADSO/IDSM (ADSO) Agda (Agda, Lagda) Amplio (amplio, dofile, startup) Ansprolog (LP) Ant (build.xml, build.xml) Gramática ANTLR (G, G4) Clase APEX (CLS) Disparador de apex (disparador) APL (APL, APLA, APLC, APLF, APLI, APLN, APLO, DYALOG, DYAPP, MIPAGE) AppleScript (AppleScript) Sketch Arduino (INO) Arkts (ETS) Arturo (arte) Asciidoc (ADOC, ASCIIDOC) ASP (ASA, ASHX, ASP, AXD) ASP.NET (ASAX, ASCX, ASMX, ASPX, Master, Sitemap, WebInfo) AspectJ (AJ) Ensamblaje (A51, ASM, NASM, S, S) Astro (Astro) Asíntota (asy) Autohotkey (ahk, ahkl) Awk (Auk, Awk, Bawk, Mawk, Nawk) Bazel (construcción) BizTalk Orchestration (ODX) BizTalk Pipeline (BTP) Blade (Blade, Blade.php) Bourne Again Shell (Bash) Bourne Shell (SH) BrightScript (BRS) Builder (XML.Builder) C (C, Cats, EC, IDC, PGC) C Shell (CSH, TCSH) C# (CS) C# Designer (Designer.cs) C ++ (C, C ++, C ++ M, CC, CCM, CPP, CPP, CPPM, CXX, CXXM, H ++, INL, IPP, IXX, PCC, TCC, TPP) Encabezado C/C ++ (H, H, HH, HPP, HXX) El Cairo (El Cairo) Script de construcción de pastel (pastel) Carbono (carbono) CCS (CCS) Capilla (CHPL) Circom (Circom) Limpiar (DCL, ICL) Clojure (Boot, CL2, CLJ, CLJS.HL, CLJSCM, CLJX, HIC, RIEMANN.CONFIG) Clojurec (CLJC) Clojurescript (CLJS) CMake (Cmake, CMake.in, CMakelists.txt) COBOL (CBL, CBL, CCP, COB, COB, COBOL, CPY) Cocoa 5 (C5, Cocoa5, Cocoa5Server, CPKG5) Coffeescript (_Coffee, CakeFile, CJSX, Coffee, Iced) Coldfusion (CFM, CFML) Coldfusion CFScript (CFC) Gramática de restricción (CG3, RLX) ContainerFile (contenedor) Coq (v) Cristal (CR) CSON (CSON) CSS (CSS) CSV (CSV) Pepino (característica) Cuda (Cu, Cuh) Cython (PXD, PXI, PYX) D (D) Dafny (DFY) Dal (DA) Dardo (dardo) Forma Delphi (DFM) Denizenscript (DSC) DERW (DERW) Dhall (Dhall) Dieta (DT) diff (diff, parche) Dita (dita) Dockerfile (Dockerfile, Dockerfile) Lenguaje de extensión de puertas (DXL) DOS Batch (Bat, Bat, BTM, BTM, CMD, CMD) Baba (DRL) DTD (DTD) dtrace (d) ECPP (ECPP) EEX (EEX) EJS (EJS) Elixir (ex, ex) Elm (Elm) Cristal incrustado (ECR) ERB (ERB, ERB) Erlang (App.Src, EMakeFile, Erl, HRL, ReRbar.Config, ReRar.Config.lock, ReRar.lock, XRL, YRL) Espere (exp) F# (FSI, FS, FS) Script F# (FSX) Hinojo (FNL) Lenguaje de estado finito (FSL, JSSM) Concha de pescado (pescado) Flatbuffers (FBS) Enfoque (FECEXEC) Forth (4th, E4, F83, Fb, Forth, FPM, FR, FRT, FT, FTH, RX, FS, F, FOR) FORTRAN 77 (F, F77, F77, para, FTN, FTN, PFO, F, FOR) Fortran 90 (F90, F90) Fortran 95 (F95, F95) Plantilla de marca libre (FTL) Futhark (FUT) FXML (FXML) Gdscript (GD) Gencat NLS (MSG) Glade (Glade, ui) Brillo (brillo) Glimmer JavaScript (GJS) TypeScript de brillo (GTS) GLSL (COMP, FP, FRAG, FRG, FSH, FSHADER, GEO, GEOM, GLSL, GLSLV, GSHADER, TESC, TESE, VERT, VRX, VSH, VSHADER) Ve (vete, ʕ◔ϖ◔ʔ) Recurso de Godot (Tres) Escena de Godot (TSCN) Godot Shaders (Gdshader) Gradle (Gradle, Gradle.kts) Grails (GSP) GraphQL (GQL, GraphQL, GraphQLS) Groovy (Gant, Groovy, GRT, GTPL, Gvy, Jenkinsfile) Haml (Haml, Haml.deface) Manillar (manillar, HBS) Puerto (HB) Liebre (ja) Haskell
