compter les lignes de code (non vides) dans bash

Dans Bash, comment compter le nombre de lignes de code non vierges dans un projet?

cat foo.c | sed '/^\s*$/d' | wc -l

Et si vous considérez les commentaires comme des lignes vides:

cat foo.pl | sed '/^\s*#/d;/^\s*$/d' | wc -l

Bien que cela dépende de la langue.

#!/bin/bash
find . -path './pma' -prune -o -path './blog' -prune -o -path './punbb' -prune -o -path './js/3rdparty' -prune -o -print | egrep '\.php|\.as|\.sql|\.css|\.js' | grep -v '\.svn' | xargs cat | sed '/^\s*$/d' | wc -l

Ce qui précède vous donnera le nombre total de lignes de code (lignes vierges supprimées) pour un projet (dossier actuel et tous les sous-dossiers de manière récursive).

Dans les fichiers ci-dessus, "./blog" "./punbb" "./js/3rdparty" et "./pma" sont des dossiers que je liste noire car je n'y ai pas écrit le code. Aussi .php, .as, .sql, .css, .js sont les extensions des fichiers examinés. Tous les fichiers avec une extension différente sont ignorés.

Si vous souhaitez utiliser autre chose qu'un script shell, essayez CLOC :

cloc compte les lignes vierges, les lignes de commentaires et les lignes physiques du code source dans de nombreux langages de programmation. Il est entièrement écrit en Perl sans dépendances en dehors de la distribution standard de Perl v5.6 et supérieur (le code de certains modules externes est intégré dans cloc) et est donc assez portable.

Il existe de nombreuses façons de faire cela, en utilisant les utilitaires shell courants.

Ma solution est:

grep -cve '^\s*$' <file>

Ceci recherche les lignes dans <file> les lignes ne correspondent pas (-v) qui correspondent au modèle (-e) '^ \ s * $', qui est le début d'une ligne, suivi de 0 ou plusieurs caractères d'espacement, suivis à la fin d'une ligne (c'est-à-dire aucun contenu autre que les espaces), et afficher un nombre de lignes correspondantes (-c) au lieu des lignes correspondantes elles-mêmes.

Un avantage de cette méthode par rapport aux méthodes qui impliquent une connexion wc, est que vous pouvez spécifier plusieurs fichiers et obtenir un décompte distinct pour chaque fichier:

$ grep -cve '^\s*$' *.hh

config.hh:36
exceptions.hh:48
layer.hh:52
main.hh:39

'wc' compte les lignes, les mots, les caractères, donc pour compter toutes les lignes (y compris les lignes vides), utilisez:

wc *.py

Pour filtrer les lignes vides, vous pouvez utiliser grep:

grep -v '^\s*$' *.py | wc

'-v' dit à grep de sortir toutes les lignes sauf celles qui correspondent à '^' est le début d'une ligne '\ s *' est zéro ou plusieurs caractères d'espacement '$' est la fin d'une ligne * .py est mon exemple pour tous les fichiers que vous souhaitez compter (tous les fichiers python dans le répertoire courant) redirigent vers wc. Allez-y.

Je réponds à ma propre question (authentique). Impossible de trouver une entrée stackoverflow qui couvre ce problème.

Cette commande compte le nombre de lignes non vides.
cat fileName | grep -v ^$ | wc -l
grep -v ^ $ fonction d'expression régulière ignore les lignes vides.

cat file.txt | awk 'NF' | wc -l

cat 'filename' | grep '[^ ]' | wc -l

devrait faire l'affaire très bien

awk '/^[[:space:]]*$/ {++x} END {print x}' "$testfile"

grep -cvE '(^\s*[/*])|(^\s*$)' foo

-c = count
-v = exclude
-E = extended regex
'(comment lines) OR (empty lines)'
where
^    = beginning of the line
\s   = whitespace
*    = any number of previous characters or none
[/*] = either / or *
|    = OR
$    = end of the line

Je poste ceci parce que d'autres options m'ont donné de mauvaises réponses. Cela a fonctionné avec ma source java, où les lignes de commentaires commencent par / ou * (j'utilise * sur chaque ligne dans les commentaires sur plusieurs lignes).

Voici un script Bash qui compte les lignes de code dans un projet. Il parcourt une arborescence source de manière récursive et exclut les lignes vides et les commentaires sur une seule ligne utilisant "//".

# $excluded is a regex for paths to exclude from line counting
excluded="spec\|node_modules\|README\|lib\|docs\|csv\|XLS\|json\|png"

countLines(){
  # $total is the total lines of code counted
  total=0
  # -mindepth exclues the current directory (".")
  for file in `find . -mindepth 1 -name "*.*" |grep -v "$excluded"`; do
    # First sed: only count lines of code that are not commented with //
    # Second sed: don't count blank lines
    # $numLines is the lines of code
    numLines=`cat $file | sed '/\/\//d' | sed '/^\s*$/d' | wc -l`

    # To exclude only blank lines and count comment lines, uncomment this:
    #numLines=`cat $file | sed '/^\s*$/d' | wc -l`

    total=$(($total + $numLines))
    echo "  " $numLines $file
  done
  echo "  " $total in total
}

echo Source code files:
countLines
echo Unit tests:
cd spec
countLines

Voici à quoi ressemble la sortie de mon projet :

Source code files:
   2 ./buildDocs.sh
   24 ./countLines.sh
   15 ./css/dashboard.css
   53 ./data/un_population/provenance/preprocess.js
   19 ./index.html
   5 ./server/server.js
   2 ./server/startServer.sh
   24 ./SpecRunner.html
   34 ./src/computeLayout.js
   60 ./src/configDiff.js
   18 ./src/dashboardMirror.js
   37 ./src/dashboardScaffold.js
   14 ./src/data.js
   68 ./src/dummyVis.js
   27 ./src/layout.js
   28 ./src/links.js
   5 ./src/main.js
   52 ./src/processActions.js
   86 ./src/timeline.js
   73 ./src/udc.js
   18 ./src/wire.js
   664 in total
Unit tests:
   230 ./ComputeLayoutSpec.js
   134 ./ConfigDiffSpec.js
   134 ./ProcessActionsSpec.js
   84 ./UDCSpec.js
   149 ./WireSpec.js
   731 in total

Prendre plaisir! - Curran

Cela dépendra un peu du nombre de fichiers que vous avez dans le projet. En théorie, vous pourriez utiliser

grep -c '.' <list of files>

Où vous pouvez remplir la liste des fichiers à l'aide de l'utilitaire de recherche.

grep -c '.' `find -type f`

Vous donnerait un nombre de lignes par fichier.

Script pour compter récursivement toutes les lignes non vides avec une certaine extension de fichier dans le répertoire courant:

#!/usr/bin/env bash
(
echo 0;
for ext in "$@"; do
    for i in $(find . -name "*$ext"); do
        sed '/^\s*$/d' $i | wc -l ## skip blank lines
        #cat $i | wc -l; ## count all lines
        echo +;
    done
done
echo p q;
) | dc;

Exemple d'utilisation:

./countlines.sh .py .java .html

Si vous voulez la somme de toutes les lignes non vierges pour tous les fichiers d'une extension de fichier donnée dans un projet:

while read line
do grep -cve '^\s*$' "$line"
done <  <(find $1 -name "*.$2" -print) | awk '{s+=$1} END {print s}'

Le premier argument est le répertoire de base du projet, le second est l'extension du fichier. Exemple d'utilisation:

./scriptname ~/Dropbox/project/src java

Ce n'est guère plus qu'une collection de solutions précédentes.

grep -v '^\W*$' `find -type f` | grep -c '.' > /path/to/lineCountFile.txt

donne un décompte global pour tous les fichiers du répertoire courant et de ses sous-répertoires.

HTH!

Cela donne le nombre de lignes sans compter les lignes vides:

grep -v ^$ filename wc -l | sed -e 's/ //g' 

rgrep . | wc -l

donne le nombre de lignes non vides dans le répertoire de travail courant.

Il existe déjà un programme pour cela sur Linux appelé «wc».

Juste

wc -l *.c 

et il vous donne le nombre total de lignes et les lignes pour chaque fichier.