conta le righe di codice (non vuote) in bash

Question

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

Answer 1

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.

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

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 " & Quot; ./ punbb " & Quot; ./ js / 3rdparty " e " ./ pma " sono cartelle che ho inserito nella lista nera 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.

Answer 3

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

  

cloc conta le righe vuote, commento   linee e linee fisiche di origine   codice in molti linguaggi di programmazione. esso   è scritto interamente in Perl con il n   dipendenze al di fuori dello standard   distribuzione di Perl v5.6 e successive   (il codice di alcuni moduli esterni è   incorporato in cloc) e così è abbastanza   portatile.

Answer 4

Esistono molti modi per farlo, usando le comuni utilità della shell.

La mia soluzione è:

grep -cve '^\s*

 Cerca le righe nel file < > le righe non corrispondenti (-v) che corrispondono al modello (-e) '^ \ s * $', che è l'inizio di una riga, seguito da 0 o più caratteri di spazi bianchi, seguito dalla 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* <file>


 Cerca le righe nel file < > le righe non corrispondenti (-v) che corrispondono al modello (-e) '^ \ s * $', che è l'inizio di una riga, seguito da 0 o più caratteri di spazi bianchi, seguito dalla 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: 

<*> *.hh

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

<file>

Cerca le righe nel file < > le righe non corrispondenti (-v) che corrispondono al modello (-e) '^ \ s * $', che è l'inizio di una riga, seguito da 0 o più caratteri di spazi bianchi, seguito dalla 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:

<*>

Answer 5

'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*

 '-v' dice a grep di produrre tutte le righe tranne quelle corrispondenti
'^' è 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)
uscita del tubo a wc. Vai via. 

 Sto rispondendo alla mia (vera) domanda. Impossibile trovare una voce dello stackoverflow che copre questo. 
 *.py | wc

'-v' dice a grep di produrre tutte le righe tranne quelle corrispondenti '^' è 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) uscita del tubo a wc. Vai via.

Sto rispondendo alla mia (vera) domanda. Impossibile trovare una voce dello stackoverflow che copre questo.

Answer 6

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.

Answer 7

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

dovrebbe fare il trucco bene

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

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).

Answer 9

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

Answer 10

Ecco uno script Bash che conta le righe di codice in un progetto. Attraversa ricorsivamente un albero dei sorgenti ed esclude le righe vuote e i 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

Buon divertimento! - Curran

Answer 11

Dipende dal numero di file che hai 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.

Answer 12

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;

Utilizzo di esempio:

./countlines.sh .py .java .html

Answer 13

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

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

<*>

È poco più di una raccolta di soluzioni precedenti.

Answer 14

grep -v '^\W*

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

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

Answer 15

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

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

Answer 16

rgrep . | wc -l

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

Answer 17

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

Proprio

wc -l *.c 

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