Compter (Non blanc) les lignes de code dans bash

#!/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 courant et tous les sous-dossiers récursivement).

au-dessus "./blog." "/ punbb" "./js / 3rdparty" et "./ pma " sont des dossiers que j'ai mis sur liste noire car je n'y ai pas écrit le code. Également. 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 voulez utiliser autre chose qu'un script shell, essayez CLOC :

cloc compte des lignes vides, commentaire lignes et lignes physiques de la source code dans de nombreux langages de programmation. Il est écrit entièrement en Perl avec aucun les dépendances à l'extérieur de la norme distribution de Perl v5.6 et plus (le code de certains modules externes est intégré dans cloc) et est donc tout à fait portable.

il y a plusieurs façons de faire cela, en utilisant des utilitaires shell communs.

ma solution est:

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

recherche des lignes dans les lignes ne correspondent pas (-v) qui correspondent au motif (-e) '^\s*$', qui est le début d'une ligne, suivi de 0 ou plus de caractères blancs, suivi de la fin d'une ligne (i.e. pas de contenu autre que l'espace), et afficher un nombre de lignes de correspondance (- c) au lieu des lignes de correspondance elles-mêmes.

un avantage de cette méthode sur les méthodes qui impliquent la tuyauterie dans wc , est que vous pouvez spécifier plusieurs fichiers et obtenir un compte séparé 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, ainsi pour compter toutes les lignes (y compris les blancs) utiliser:

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 égal à zéro ou plus de caractères blancs '$' est la fin d'une ligne *.py est mon exemple pour tous les fichiers que vous souhaitez le comte (tous les fichiers python dans le répertoire courant) sortie du tuyau vers le wc. Hors vous aller.

je réponds à ma propre question. Je n'ai pas trouvé d'entrée pour couvrir ça.

cette commande compte le nombre de lignes non vides dans notre projet.

cat fileName | grep -v ^$ | wc -l

grep -v ^$ expression régulière fonction est ignorer les lignes vides.

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

devrait faire l'affaire très bien

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 java source, où les lignes de commentaire commencent par / ou * (j'utilise * sur chaque ligne dans le commentaire multi-ligne).

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

voici un script Bash qui compte les lignes de code dans un projet. Il traverse une arborescence des sources de façon récursive, et il exclut les lignes vierges et les commentaires de ligne simple 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 la sortie 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-en! -- Curran

ça va dépendre 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 find.

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

vous donnerait un nombre de lignes par fichier.

Script pour recursively count toutes les lignes non Vierges 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 tout au long d'un projet:

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

premier arg est le répertoire de base du projet, deuxième 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.

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

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

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

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

HTH!

rgrep . | wc -l

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

il y a déjà un programme pour cela sur linux appelé 'wc'.

juste

wc -l *.c 

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