Conteggio ricorsivo dei file in una directory Linux

Come posso contare ricorsivamente i file in una directory Linux?

Ho trovato questo:

find DIR_NAME -type f ¦ wc -l

Ma quando eseguo questo restituisce il seguente errore.

trova: i percorsi devono precedere l'espressione: ¦

Questo dovrebbe funzionare:

find DIR_NAME -type f | wc -l

Spiegazione:

• -type f per includere solo i file.
• |( e non¦ ) reindirizza findl'output standard del wccomando all'input standard del comando.
• wc(abbreviazione di conteggio parole) conta nuove righe, parole e byte sul suo input ( documenti ).
• -l contare solo le nuove righe.

Appunti:

• Sostituisci DIR_NAMEcon .per eseguire il comando nella cartella corrente.
• Puoi anche rimuovere le -type fdirectory da includere (e i collegamenti simbolici) nel conteggio.
• È possibile che questo comando superi il numero se i nomi dei file possono contenere caratteri di nuova riga.

Spiegazione del motivo per cui il tuo esempio non funziona:

Nel comando che hai mostrato, non usi "Pipe" ( |) per collegare due comandi, ma la barra spezzata ( ¦) che la shell non riconosce come comando o qualcosa di simile. Ecco perché ricevi quel messaggio di errore.

Per la directory corrente:

find -type f | wc -l

Se vuoi una ripartizione di quanti file sono presenti in ogni directory sotto la tua directory corrente:

for i in */ .*/ ; do 
    echo -n $i": " ; 
    (find "$i" -type f | wc -l) ; 
done

Questo può andare tutto su una riga, ovviamente. La parentesi chiarisce di chi wc -ldovrebbe essere l' output a guardare ( find $i -type fin questo caso).

Puoi usare

$ tree

dopo aver installato il pacchetto albero con

$ sudo apt-get install tree

(su una macchina Debian / Mint / Ubuntu Linux).

Il comando mostra non solo il conteggio dei file, ma anche il conteggio delle directory, separatamente. L'opzione -L può essere utilizzata per specificare il livello di visualizzazione massimo (che, per impostazione predefinita, è la profondità massima della struttura di directory).

Anche i file nascosti possono essere inclusi fornendo l' -aopzione.

Sul mio computer, rsyncè un po 'più veloce rispetto find | wc -lalla risposta accettata:

$ rsync --stats --dry-run -ax /path/to/dir /tmp

Number of files: 173076
Number of files transferred: 150481
Total file size: 8414946241 bytes
Total transferred file size: 8414932602 bytes

La seconda riga ha il numero di file, 150.481 nell'esempio sopra. Come bonus ottieni anche la dimensione totale (in byte).

Osservazioni:

• la prima riga è un conteggio di file, directory, collegamenti simbolici, ecc. tutti insieme, ecco perché è più grande della seconda riga.
• l' opzione --dry-run(o -nin breve) è importante per non trasferire effettivamente i file!
• Ho usato l' -xopzione per "non oltrepassare i confini del filesystem", il che significa che se lo esegui /e hai dei dischi rigidi esterni collegati, conterà solo i file sulla partizione di root.

Poiché i nomi di file in UNIX possono contenere newline (sì, newline), è wc -lpossibile che vengano conteggiati troppi file. Vorrei stampare un punto per ogni file e quindi contare i punti:

find DIR_NAME -type f -printf "." | wc -c

Combinando insieme alcune delle risposte qui, la soluzione più utile sembra essere:

find . -maxdepth 1 -type d -print0 |
xargs -0 -I {} sh -c 'echo -e $(find "{}" -printf "\n" | wc -l) "{}"' |
sort -n

Può gestire cose strane come nomi di file che includono spazi tra parentesi e persino nuove righe. Ordina inoltre l'output in base al numero di file.

È possibile aumentare il numero dopo -maxdepthper contare anche le sottodirectory. Tieni presente che ciò potrebbe richiedere molto tempo, in particolare se hai una struttura di directory altamente nidificata in combinazione con un -maxdepthnumero elevato .

Se vuoi sapere quanti file e sottodirectory esistono dalla presente directory di lavoro, puoi usare questo one-liner

find . -maxdepth 1 -type d -print0 | xargs -0 -I {} sh -c 'echo -e $(find {} | wc -l) {}' | sort -n

Funzionerà con GNU, e omette -e dal comando echo per BSD linux (es. OSX).

Se si desidera evitare casi di errore, non consentire la wc -lvisualizzazione di file con newline (che verranno conteggiati come 2+ file)

ad esempio, considera un caso in cui abbiamo un singolo file con un singolo carattere EOL in esso

> mkdir emptydir && cd emptydir
> touch $'file with EOL(\n) character in it'
> find -type f
./file with EOL(?) character in it
> find -type f | wc -l
2

Poiché almeno gnu wcnon sembra avere un'opzione per leggere / contare un elenco con terminazione null (tranne che da un file), la soluzione più semplice sarebbe semplicemente non passargli i nomi dei file, ma un output statico ogni volta che viene trovato un file, ad es. nella stessa directory di cui sopra

> find -type f -exec printf '\n' \; | wc -l
1

O se findlo supporta

> find -type f -printf '\n' | wc -l
1 

È possibile utilizzare il comando ncdu. Conterà ricorsivamente quanti file contiene una directory Linux. Ecco un esempio di output:

Ha una barra di avanzamento, che è utile se hai molti file:

Per installarlo su Ubuntu:

sudo apt-get install -y ncdu

Punto di riferimento: ho usato https://archive.org/details/cv_corpus_v1.tar (380390 file, 11 GB) come cartella in cui si deve contare il numero di file.

• find . -type f | wc -l: circa 1m20s per il completamento
• ncdu: circa 1m20s per il completamento

tree $DIR_PATH | tail -1

Uscita campione:

5309 directory, 2122 file

Per determinare quanti file ci sono nella directory corrente, inserire ls -1 | wc -l. Questo utilizza wcper fare un conteggio del numero di righe (-l)nell'output di ls -1. Non conta i dotfile. Si noti che ls -l(questa è una "L" piuttosto che un "1" come negli esempi precedenti) che ho usato nelle versioni precedenti di questo HOWTO in realtà vi darà un conteggio di file superiore a quello effettivo. Grazie a Kam Nejad per questo punto.

Se vuoi contare solo i file e NON includere collegamenti simbolici (solo un esempio di cos'altro potresti fare), potresti usare ls -l | grep -v ^l | wc -l(questa volta questa è una "L" e non un "1", qui vogliamo un elenco "lungo") . grepcontrolla qualsiasi riga che inizia con "l" (che indica un collegamento) e scarta quella linea (-v).

Velocità relativa: "ls -1 / usr / bin / | wc -l" richiede circa 1,03 secondi su un 486SX25 non caricato (/ usr / bin / su questa macchina ha 355 file). " ls -l /usr/bin/ | grep -v ^l | wc -l" richiede circa 1,19 secondi.

Fonte: http://www.tldp.org/HOWTO/Bash-Prompt-HOWTO/x700.html

Se ciò di cui hai bisogno è contare ricorsivamente un tipo di file specifico , puoi fare:

find YOUR_PATH -name '*.html' -type f | wc -l 

-l è solo per visualizzare il numero di righe nell'output.

Con bash:

Crea una matrice di voci con () e ottieni il con #.

FILES=(./*); echo ${#FILES[@]}

Ok, non conta in modo ricorsivo i file ma prima volevo mostrare la semplice opzione. Un caso d'uso comune potrebbe essere la creazione di backup di rollover di un file. Questo creerà logfile.1, logfile.2, logfile.3 ecc.

CNT=(./logfile*); mv logfile logfile.${#CNT[@]}

Conteggio ricorsivo con bash 4+ globstarabilitato (come indicato da @tripleee)

FILES=(**/*); echo ${#FILES[@]}

Per ottenere il conteggio dei file in modo ricorsivo possiamo ancora usare find allo stesso modo.

FILES=(`find . -type f`); echo ${#FILES[@]}

Per le directory con spazi nel nome ... (basato su varie risposte sopra) - stampa ricorsivamente il nome della directory con il numero di file all'interno di:

find . -mindepth 1 -type d -print0 | while IFS= read -r -d '' i ; do echo -n $i": " ; ls -p "$i" | grep -v / | wc -l ; done

Esempio (formattato per la leggibilità):

pwd
  /mnt/Vancouver/Programming/scripts/claws/corpus

ls -l
  total 8
  drwxr-xr-x 2 victoria victoria 4096 Mar 28 15:02 'Catabolism - Autophagy; Phagosomes; Mitophagy'
  drwxr-xr-x 3 victoria victoria 4096 Mar 29 16:04 'Catabolism - Lysosomes'

ls 'Catabolism - Autophagy; Phagosomes; Mitophagy'/ | wc -l
  138

## 2 dir (one with 28 files; other with 1 file):
ls 'Catabolism - Lysosomes'/ | wc -l
  29

La struttura della directory viene visualizzata meglio usando tree:

tree -L 3 -F .
  .
  ├── Catabolism - Autophagy; Phagosomes; Mitophagy/
  │   ├── 1
  │   ├── 10
  │   ├── [ ... SNIP! (138 files, total) ... ]
  │   ├── 98
  │   └── 99
  └── Catabolism - Lysosomes/
      ├── 1
      ├── 10
      ├── [ ... SNIP! (28 files, total) ... ]
      ├── 8
      ├── 9
      └── aaa/
          └── bbb

  3 directories, 167 files

man find | grep mindep
  -mindepth levels
    Do not apply any tests or actions at levels less than levels
    (a non-negative integer).  -mindepth 1 means process all files
    except the starting-points.

ls -p | grep -v /(utilizzato di seguito) proviene dalla risposta 2 all'indirizzo /unix/48492/list-only-regular-files-but-not-directories-in-current-directory

find . -mindepth 1 -type d -print0 | while IFS= read -r -d '' i ; do echo -n $i": " ; ls -p "$i" | grep -v / | wc -l ; done
./Catabolism - Autophagy; Phagosomes; Mitophagy: 138
./Catabolism - Lysosomes: 28
./Catabolism - Lysosomes/aaa: 1

Applcation: Voglio trovare il numero massimo di file tra diverse centinaia di directory (tutta la profondità = 1) [l'output di seguito è stato nuovamente formattato per la leggibilità]:

date; pwd
    Fri Mar 29 20:08:08 PDT 2019
    /home/victoria/Mail/2_RESEARCH - NEWS

time find . -mindepth 1 -type d -print0 | while IFS= read -r -d '' i ; do echo -n $i": " ; ls -p "$i" | grep -v / | wc -l ; done > ../../aaa
    0:00.03

[victoria@victoria 2_RESEARCH - NEWS]$ head -n5 ../../aaa
    ./RNA - Exosomes: 26
    ./Cellular Signaling - Receptors: 213
    ./Catabolism - Autophagy; Phagosomes; Mitophagy: 138
    ./Stress - Physiological, Cellular - General: 261
    ./Ancient DNA; Ancient Protein: 34

[victoria@victoria 2_RESEARCH - NEWS]$ sed -r 's/(^.*): ([0-9]{1,8}$)/\2: \1/g' ../../aaa | sort -V | (head; echo ''; tail)

    0: ./Genomics - Gene Drive
    1: ./Causality; Causal Relationships
    1: ./Cloning
    1: ./GenMAPP 2
    1: ./Pathway Interaction Database
    1: ./Wasps
    2: ./Cellular Signaling - Ras-MAPK Pathway
    2: ./Cell Death - Ferroptosis
    2: ./Diet - Apples
    2: ./Environment - Waste Management

    988: ./Genomics - PPM (Personalized & Precision Medicine)
    1113: ./Microbes - Pathogens, Parasites
    1418: ./Health - Female
    1420: ./Immunity, Inflammation - General
    1522: ./Science, Research - Miscellaneous
    1797: ./Genomics
    1910: ./Neuroscience, Neurobiology
    2740: ./Genomics - Functional
    3943: ./Cancer
    4375: ./Health - Disease 

sort -Vè un tipo naturale. ... Quindi, il mio numero massimo di file in una di quelle directory (Claws Mail) è di 4375 file. Se avessi lasciato il pad ( https://stackoverflow.com/a/55409116/1904943 ) quei nomi di file - sono tutti nominati numericamente, a partire da 1, in ciascuna directory - e pad a 5 cifre totali, dovrei essere ok .

appendice

Trova il numero totale di file, sottodirectory in una directory.

$ date; pwd
Tue 14 May 2019 04:08:31 PM PDT
/home/victoria/Mail/2_RESEARCH - NEWS

$ ls | head; echo; ls | tail
Acoustics
Ageing
Ageing - Calorie (Dietary) Restriction
Ageing - Senescence
Agriculture, Aquaculture, Fisheries
Ancient DNA; Ancient Protein
Anthropology, Archaeology
Ants
Archaeology
ARO-Relevant Literature, News

Transcriptome - CAGE
Transcriptome - FISSEQ
Transcriptome - RNA-seq
Translational Science, Medicine
Transposons
USACEHR-Relevant Literature
Vaccines
Vision, Eyes, Sight
Wasps
Women in Science, Medicine

$ find . -type f | wc -l
70214    ## files

$ find . -type d | wc -l
417      ## subdirectories

Ho scritto ffcnt per accelerare il conteggio dei file ricorsivi in ​​circostanze specifiche: dischi rotazionali e filesystem che supportano la mappatura dell'estensione.

Può essere un ordine di grandezza più veloce lso findbasato su approcci, ma YMMV.

Ci sono molte risposte corrette qui. Eccone un altro!

find . -type f | sort | uniq -w 10 -c

dove si .trova la cartella in cui cercare ed 10è il numero di caratteri per cui raggruppare la directory.

trova-tipo f | wc -l

OPPURE (Se la directory è la directory corrente)

trova . -tipo f | wc -l

Funzionerà perfettamente. Insomma semplice. Se si desidera contare il numero di file presenti in una cartella.

ls | wc -l

Questo approccio alternativo con il filtro per il formato conta tutti i moduli del kernel grub disponibili:

ls -l /boot/grub/*.mod | wc -l

ls -l | grep -e -x -e -dr | wc -l 

1. lunga lista
2. filtra file e directory
3. contare la linea filtrata n