web-dev-qa-db-fra.com

compter les lignes de code (non vides) dans bash

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

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

Et si vous considérez les lignes vierges des commentaires:

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

Bien que cela dépende de la langue. 

165
Michael Cramer
#!/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 vides supprimées) pour un projet (dossier actuel et tous les sous-dossiers de manière récursive).

Dans ce qui précède, "./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.

50
Gilles

Si vous voulez utiliser autre chose qu'un script Shell, essayez CLOC :

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

31
xsl

Il existe plusieurs façons de procéder, en utilisant des utilitaires Shell courants.

Ma solution est:

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

Ceci recherche les lignes dans <fichier> les lignes ne correspondant pas (-v) qui correspondent au modèle (-e) '^\s * $', qui est le début d'une ligne, suivi de 0 ou de plusieurs espaces, suivi à la fin d'une ligne (c.-à-d. aucun contenu autre que des espaces) et affiche le 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 de canaliser dans wc est que vous pouvez spécifier plusieurs fichiers et obtenir un nombre séparé pour chaque fichier:

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

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

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

wc *.py

Pour filtrer les lignes vides, vous pouvez utiliser grep:

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

'-v' demande à grep d'afficher toutes les lignes sauf celles qui correspondent '^' correspond au début d'une ligne '\ s *' correspond à zéro ou plusieurs caractères d'espacement '$' correspond à la fin de une ligne *. py est mon exemple pour tous les fichiers que vous souhaitez compter (tous les fichiers python du répertoire en cours) dirigez la sortie vers wc. Vous partez.

Je réponds à ma propre (véritable) question. Impossible de trouver une entrée stackoverflow couvrant ce sujet.

13
Jonathan Hartley

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

6
coastline
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 ont donné de mauvaises réponses pour moi. Cela a fonctionné avec mon source Java, où les lignes de commentaire commencent par/ou * (j'utilise * sur chaque ligne dans un commentaire multiligne).

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

devrait faire l'affaire très bien

4
curtisk
awk '/^[[:space:]]*$/ {++x} END {print x}' "$testfile"
3
Ben Hoffstein

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 d'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 le résultat pour 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

2
curran

Si vous voulez la somme de toutes les lignes non vides pour tous les fichiers d'une extension 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

C'est un peu plus qu'une collection de solutions précédentes.

1
Andy

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 en utilisant l'utilitaire de recherche.

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

Vous donnerait un nombre de lignes par fichier.

1
Linor

Script permettant de compter récursivement toutes les lignes non vides avec une certaine extension de fichier dans le répertoire actuel

#!/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
1
Keith Pinson

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

grep -v ^$ filename wc -l | sed -e 's/ //g'
1
mahesh
grep -v '^\W*$' `find -type f` | grep -c '.' > /path/to/lineCountFile.txt

donne un nombre agrégé pour tous les fichiers du répertoire en cours et de ses sous-répertoires.

HTH!

0
Dutch
rgrep . | wc -l

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

0
jean-emmanuel