conta le righe di codice (non vuote) in bash

In Bash, come posso contare il numero di righe di codice non vuote in un progetto?

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

E se consideri i commenti righe vuote:

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

Anche se dipende dalla lingua.

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

Quanto sopra ti fornirà il conteggio totale delle righe di codice (righe vuote rimosse) per un progetto (cartella corrente e tutte le sottocartelle in modo ricorsivo).

Nel precedente "./blog" "./punbb" "./js/3rdparty" e "./pma" sono le cartelle che inserisco nella blacklist perché non ho scritto il codice in esse. Anche .php, .as, .sql, .css, .js sono le estensioni dei file esaminati. Tutti i file con un'estensione diversa vengono ignorati.

Se vuoi usare qualcosa di diverso da uno script di shell, prova CLOC :

cloc conta le righe vuote, le righe di commento e le righe fisiche del codice sorgente in molti linguaggi di programmazione. È scritto interamente in Perl senza dipendenze al di fuori della distribuzione standard di Perl v5.6 e successive (il codice di alcuni moduli esterni è incorporato in cloc) e quindi è abbastanza portatile.

Esistono molti modi per farlo, utilizzando le utilità di shell comuni.

La mia soluzione è:

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

Questo cerca le righe in <file> le righe non corrispondenti (-v) che corrispondono al modello (-e) '^ \ s * $', che è l'inizio di una riga, seguito da 0 o più caratteri spazi bianchi, seguito entro la fine di una riga (ovvero nessun contenuto diverso dagli spazi bianchi) e visualizza un conteggio delle righe corrispondenti (-c) invece delle stesse righe corrispondenti.

Un vantaggio di questo metodo rispetto ai metodi che prevedono il piping in wcè che puoi specificare più file e ottenere un conteggio separato per ogni file:

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

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

'wc' conta linee, parole, caratteri, quindi per contare tutte le linee (comprese quelle vuote) usa:

wc *.py

Per filtrare le righe vuote, puoi usare grep:

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

'-v' dice a grep di produrre tutte le righe tranne quelle che corrispondono a '^' è l'inizio di una riga '\ s *' è zero o più caratteri di spazi bianchi '$' è la fine di una riga * .py è il mio esempio per tutti i file che si desidera contare (tutti i file Python nella directory corrente) restituiscono l'output al wc. Vai via.

Sto rispondendo alla mia (vera) domanda. Impossibile trovare una voce di StackOverflow che trattasse questo.

Questo comando conta il numero di righe non vuote.
cat fileName | grep -v ^$ | wc -l
grep -v ^ $ la funzione di espressione regolare ignora le righe vuote.

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

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

dovrebbe fare il trucco bene

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

Pubblico questo perché altre opzioni mi hanno dato risposte sbagliate. Questo ha funzionato con la mia fonte java, dove le righe di commento iniziano con / o * (uso * su ogni riga del commento su più righe).

Ecco uno script Bash che conta le righe di codice in un progetto. Attraversa ricorsivamente un albero di origine ed esclude righe vuote e commenti a riga singola che utilizzano "//".

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

Ecco come appare l'output per il mio progetto :

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

Godere! - Curran

Dipende dal numero di file presenti nel progetto. In teoria potresti usare

grep -c '.' <list of files>

Dove è possibile compilare l'elenco dei file utilizzando l'utilità di ricerca.

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

Ti darebbe un conteggio di riga per file.

Script per contare ricorsivamente tutte le righe non vuote con una determinata estensione di file nella directory corrente:

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

Esempio di utilizzo:

./countlines.sh .py .java .html

Se si desidera la somma di tutte le righe non vuote per tutti i file di una determinata estensione nel corso di un progetto:

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

Il primo argomento è la directory di base del progetto, il secondo è l'estensione del file. Esempio di utilizzo:

./scriptname ~/Dropbox/project/src java

È poco più di una raccolta di soluzioni precedenti.

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

fornisce un conteggio aggregato per tutti i file nella directory corrente e nelle sue sottodirectory.

HTH!

Ciò fornisce il conteggio del numero di righe senza contare le righe vuote:

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

rgrep . | wc -l

fornisce il conteggio delle righe non vuote nella directory di lavoro corrente.

Esiste già un programma per questo su Linux chiamato 'wc'.

Appena

wc -l *.c 

e ti dà le linee totali e le linee per ogni file.