Come scoprire quante righe di codice ci sono in un progetto Xcode?

C'è un modo per determinare quante righe di codice contiene un progetto Xcode? Prometto di non utilizzare tali informazioni a fini di misurazione manageriale o benchmarking dei dipendenti. ;)

Dai un'occhiata a CLOC .

cloc conta le righe vuote, le righe di commento e le righe fisiche del codice sorgente in molti linguaggi di programmazione.

(Le build legacy sono archiviate su SourceForge .)

Vedo questo fluttuare in giro e lo uso da solo:

find . "(" -name "*.m" -or -name "*.mm" -or -name "*.cpp" -or -name "*.swift" ")" -print0 | xargs -0 wc -l

Ho usato CLOC come menzionato daNathan Kinsinger ed è abbastanza facile da usare. È uno script PERL che è possibile aggiungere ed eseguire dalla directory del progetto.

PERL fa già parte di Mac OS e puoi invocare lo script in questo modo per scoprire il tuo numero di righe che hai scritto:

perl cloc-1.56.pl ./YourDirectoryWhereYourSourcesAre

Questo è un esempio di output ottenuto da tale comando:

   176 text files.
   176 unique files.                                          
     4 files ignored.

http://cloc.sourceforge.net v 1.56  T=2.0 s (86.0 files/s, 10838.0 lines/s)
-------------------------------------------------------------------------------
Language                     files          blank        comment           code
-------------------------------------------------------------------------------
Objective C                     80           3848           1876          11844
C/C++ Header                    92            980           1716           1412
-------------------------------------------------------------------------------
SUM:                           172           4828           3592          13256
-------------------------------------------------------------------------------

Apri Terminal.app, vai nella directory principale del tuo progetto ed esegui questo comando:

Solo per Swift:

find . \( -iname \*.swift \) -exec wc -l '{}' \+

Solo per Obj-C:

find . \( -iname \*.m -o -iname \*.mm -o -iname \*.h \) -exec wc -l '{}' \+

Per Obj-C + Swift:

find . \( -iname \*.m -o -iname \*.mm -o -iname \*.h -o -iname \*.swift \) -exec wc -l '{}' \+

Per Obj-C + Swift + C + C ++:

find . \( -iname \*.m -o -iname \*.mm -o -iname \*.c -o -iname \*.cc -o -iname \*.h -o -iname \*.hh -o -iname \*.hpp -o -iname \*.cpp -o -iname \*.swift \) -exec wc -l '{}' \+

Suggerimenti rapidi per il terminale:
ls: elenca il contenuto della directory
cd: cambia directory
Premi la scheda per completare automaticamente
Ricorda di mettere la barra rovesciata "\" prima degli spazi
Suggerisco di andare giù di una cartella dal progetto principale in modo da eliminare il conteggio del codice dai framework

Nel terminale, passare alla directory del progetto ed eseguire:

find . -type f -print0 | xargs -0 cat | wc -l

Se vuoi solo determinati tipi di file, prova qualcosa del genere

find . -type f -name \*.[ch]* -print0 | xargs -0 cat | wc -l

Dai un'occhiata a Xcode Statistician, fa esattamente quello che vuoi. Fornisce anche altre statistiche interessanti, quindi vale la pena correre per divertimento di tanto in tanto.

Nota che non apparirà all'interno di cartelle reali, anche se apparirà in gruppi. Probabilmente non stai usando cartelle reali, quindi funzionerà alla grande. Se stai usando le cartelle, devi solo fare il conteggio in ciascuna cartella e sommarle.

Nota: a partire da giugno 2012, sembra che questo non funzioni correttamente con le ultime versioni di Xcode.

1. terminale aperto
2. vai al tuo progetto

3. eseguire il comando seguente all'interno del progetto:

   find . -path ./Pods -prune -o -name "*.swift" -print0 ! -name "/Pods" | xargs -0 wc -l

   O:

   find . -path ./Pods -prune -o -name "*[hm]" -print0 ! -name "/Pods" | xargs -0 wc -l

(* Escludendo il conteggio dei file pod dal conteggio totale)

Se vai alla directory del tuo progetto nel terminale e inserisci:

find . "(" -name "*.h" -or -name "*.m" -or -name "*.mm" -or -name "*.hpp" -or -name "*.cpp"  -or  -name "*.c" -or -name "*.cc" -or -name "*.swift" ")" -print0 | xargs -0 wc -l

Ciò fornirà una suddivisione del progetto, nonché il totale della linea per ciascun file e il progetto nel suo insieme.

La versione di Nozzi non funziona per me, ma questa:

find . -type f -print0 | xargs -0 cat | wc -l

Un modo semplice e veloce:

Usa una ricerca regex (Trova Navigator, scegli Trova> Espressione regolare).

. \ N

Funziona comodamente con gli ambiti di ricerca Xcode e puoi personalizzarlo facilmente su qualsiasi tipo di linea che desideri contare;).

Puoi installare SLOCCount tramite MacPorts . O, più rozzamente, puoi usare wc -l.

Non ho familiarità con xcode, ma se tutto ciò che serve è contare il numero di righe da tutti quei file specifici all'interno di un albero di directory, è possibile utilizzare il seguente comando:

find .... match of all those files ... -exec wc -l {} +

Seguendo la risposta di Joshua Nozzi , in GNU trovare l'espressione regolare per tali file sarebbe come:

find . "(" -name "*.m" -or -name "*.mm" -or -name "*.cpp" -or -name "*.swift" ")" -exec wc -l {} +

o anche

find -regex ".*\.\(m\|mm\|cpp\|swift\)$" -exec wc -l {} +

questo utilizza un'espressione regolare per abbinare tutti i file che terminano in due .m, .mm, .cppo .swift. Puoi vedere maggiori informazioni su quelle espressioni in Come usare regex nella ricerca di file .

Se stai lavorando con Mac OS find , allora hai bisogno di un approccio leggermente diverso, come spiegato da Motti Shneor nei commenti:

find -E . -regex ".*\.([hmc]|mm|cp+|swift|pch)$" -exec wc -l {} +

Entrambi forniranno un output sotto forma di:

234 ./file1
456 ./file2
690 total

Quindi puoi mantenerlo in questo modo o semplicemente reindirizzare tail -1(cioè find ... | tail -1) in modo che l'ultima riga sia il totale.

Scusa per la ripetizione. Questo è il modo più semplice IMHO:

1. Nel tipo di terminale

find /users/<#username#>/documents/folderWithProject/ -type f -exec cp {} /users/<#username#>/documents/folderWithProject/newFolder/ \;

Questo copierà tutti i file dalla cartella del progetto a newFolder.

2. Scarica Xcode Statistician e usalo connewFolder

line-counterè una buona alternativa. È più leggero di CLOC e molto più potente e più facile da usare rispetto ad altri comandi.

Una rapida panoramica

Ecco come si ottiene lo strumento

$ pip install line-counter

Utilizzare il linecomando per ottenere il conteggio dei file e il conteggio delle righe nella directory corrente (ricorsivamente)

$ line
Search in /Users/Morgan/Documents/Example/
file count: 4
line count: 839

Se vuoi maggiori dettagli, basta usare line -d.

$ line -d
Search in /Users/Morgan/Documents/Example/
Dir A/file C.c                                             72
Dir A/file D.py                                           268
file A.py                                                 467
file B.c                                                   32
file count: 4
line count: 839

E la parte migliore di questo strumento è, è possibile aggiungere .gitignore come configurare il file ad esso. È possibile impostare regole per selezionare o ignorare quale tipo di file contare esattamente come quello che si fa in '.gitignore'. Sì, questo strumento è stato appena inventato per sapere quante linee ho più facile.

Ulteriori descrizioni e utilizzo sono disponibili qui: https://github.com/MorganZhang100/line-counter

Sono l'autore di questo semplice strumento. Spero che possa aiutare qualcuno.