compter les lignes de code (non vides) dans bash

Question

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

Answer 1

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

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

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

Bien que cela dépende de la langue.

Answer 2

#!/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’ai pas écrit le code qu’ils contiennent. Aussi, .php, .as, .sql, .css, .js sont les extensions des fichiers examinés. Tous les fichiers ayant une extension différente sont ignorés.

Answer 3

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

  

cloc compte les lignes vides, commentaire   lignes et lignes physiques de la source   code dans de nombreux langages de programmation. Il   est écrit entièrement en Perl sans   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 est donc assez   portable.

Answer 4

Il existe de nombreuses façons de procéder, en utilisant des utilitaires shell communs.

Ma solution est la suivante:

grep -cve '^\s*

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

 Un avantage de cette méthode par rapport aux méthodes qui impliquent une canalisation dans  wc  est que vous pouvez spécifier plusieurs fichiers et obtenir un nombre séparé pour chaque fichier: 

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


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

 Un avantage de cette méthode par rapport aux méthodes qui impliquent une canalisation dans  wc  est que vous pouvez spécifier plusieurs fichiers et obtenir un nombre séparé pour chaque fichier: 

<*> *.hh

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

<file>

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

Un avantage de cette méthode par rapport aux méthodes qui impliquent une canalisation dans wc est que vous pouvez spécifier plusieurs fichiers et obtenir un nombre séparé pour chaque fichier:

<*>

Answer 5

'wc' compte les lignes, les mots et 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*

 '- v' indique à grep d'afficher toutes les lignes sauf celles qui correspondent
'^' est le début d'une ligne
'\ s *' correspond à 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 du répertoire courant)
tuyau de sortie à wc. Vous partez. 

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

'- v' indique à grep d'afficher toutes les lignes sauf celles qui correspondent '^' est le début d'une ligne '\ s *' correspond à 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 du répertoire courant) tuyau de sortie à wc. Vous partez.

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

Answer 6

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

Answer 7

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

devrait faire l'affaire très bien

Answer 8

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 car d’autres options m’ont donné de mauvaises réponses. Cela a fonctionné avec ma source java, où les lignes de commentaire commencent par / ou * (j'utilise * sur chaque ligne dans un commentaire multiligne).

Answer 9

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

Answer 10

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 vierges et les commentaires sur une seule ligne qui utilisent "//".

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

Profitez! - Curran

Answer 11

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.

Answer 12

Le script compte de manière récursive toutes les lignes non vides avec une certaine extension de fichier dans le répertoire en cours:

#!/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

Answer 13

Si vous souhaitez que la somme de toutes les lignes non vides de tous les fichiers d'une extension donnée soit contenue dans un projet:

while read line
do grep -cve '^\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. 
 "$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:

<*>

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

Answer 14

grep -v '^\W*

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

 HTH! 
 `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!

Answer 15

Ceci donne le nombre de lignes sans compter les lignes vierges:

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

Answer 16

rgrep . | wc -l

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

Answer 17

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.