Come trovare il file più grande in una directory e nelle sue sottodirectory?

Stiamo appena iniziando una classe UNIX e stiamo imparando una varietà di comandi Bash. Il nostro compito implica l'esecuzione di vari comandi su una directory che ha anche un numero di cartelle sotto di essa.

So come elencare e contare tutti i file normali dalla cartella principale utilizzando:

find . -type l | wc -l

Ma mi piacerebbe sapere dove andare da lì per trovare il file più grande dell'intera directory. Ho visto qualcosa riguardo a un ducomando, ma non l'abbiamo imparato, quindi nel repertorio di cose che abbiamo imparato presumo che dobbiamo collegarlo in qualche modo al ls -tcomando.

E perdonami se il mio "gergo" non è corretto, mi ci sto ancora abituando!

Citazione da questo link-

Se si desidera trovare e stampare i primi 10 nomi di file più grandi (non directory) in una determinata directory e nelle sue sottodirectory

$ find . -printf '%s %p\n'|sort -nr|head

Per restringere la ricerca alla directory attuale usa "-maxdepth 1" con find.

$ find . -maxdepth 1 -printf '%s %p\n'|sort -nr|head

E per stampare i primi 10 "file e directory" più grandi:

$ du -a . | sort -nr | head

** Usa "head -n X" invece dell'unica "head" sopra per stampare i primi X file più grandi (in tutti gli esempi precedenti)

Per trovare i primi 25 file nella directory corrente e nelle sue sottodirectory:

find . -type f -exec ls -al {} \; | sort -nr -k5 | head -n 25

Questo produrrà i primi 25 file ordinandoli in base alla dimensione dei file tramite il comando piped "sort -nr -k5".

Lo stesso ma con dimensioni di file leggibili dall'uomo:

find . -type f -exec ls -alh {} \; | sort -hr -k5 | head -n 25

find . -type f | xargs ls -lS | head -n 1

uscite

-rw-r--r--  1 nneonneo  staff  9274991 Apr 11 02:29 ./devel/misc/test.out

Se vuoi solo il nome del file:

find . -type f | xargs ls -1S | head -n 1

Questo evita l'uso awke ti consente di usare qualsiasi flag tu voglia ls.

Avvertimento . Poiché xargscerca di evitare di creare righe di comando troppo lunghe, potrebbe non riuscire se lo esegui su una directory con molti file perché lsfinisce per essere eseguito più di una volta. Non è un problema insormontabile (puoi raccogliere l' head -n 1output da ogni lsinvocazione ed eseguire di ls -Snuovo, ripetendo il ciclo finché non hai un singolo file), ma in qualche modo rovina questo approccio.

Non è disponibile un semplice comando per trovare i file / directory più grandi su un filesystem Linux / UNIX / BSD. Tuttavia, la combinazione dei seguenti tre comandi (utilizzando pipe) è possibile trovare facilmente l'elenco dei file più grandi:

# du -a /var | sort -n -r | head -n 10

Se vuoi un output più leggibile dall'uomo prova:

$ cd /path/to/some/var
$ du -hsx * | sort -rh | head -10

Dove,

• Var è la directory in cui vuoi cercare
• opzione du comando -h: visualizza le dimensioni in un formato leggibile dall'uomo (ad esempio, 1K, 234M, 2G).
• opzione du comando -s: mostra solo un totale per ogni argomento (sommario).
• opzione du comando -x: salta le directory su diversi file system.
• comando di ordinamento -r opzione: inverte il risultato dei confronti.
• comando di ordinamento -h opzione: confronta i numeri leggibili dall'uomo. Questa è solo un'opzione specifica per l'ordinamento GNU.
• comando head -10 OPPURE opzione -n ​​10: mostra le prime 10 righe.

Questo elenca i file in modo ricorsivo se sono file normali, ordina in base al settimo campo (che è la dimensione nel mio findoutput; controlla il tuo) e mostra solo il primo file.

find . -type f -ls | sort +7 | head -1

La prima opzione findè il percorso iniziale per la ricerca ricorsiva. Un tipo di fricerca di file normali. Nota che se provi ad analizzarlo come un nome di file, potresti non riuscire se il nome di file contiene spazi, nuove righe o altri caratteri speciali. Le opzioni possono sortvariare anche in base al sistema operativo. Sto usando FreeBSD.

Una soluzione "migliore" ma più complessa e più pesante sarebbe quella di findattraversare le directory, ma forse usarla statper ottenere i dettagli sul file, quindi forse usarla awkper trovare la dimensione massima. Nota che l'output di statdipende anche dal tuo sistema operativo.

Questo troverà il file o la cartella più grande nella tua attuale directory di lavoro:

ls -S /path/to/folder | head -1

Per trovare il file più grande in tutte le sottodirectory:

find /path/to/folder -type f -exec ls -s {} \; | sort -nr | awk 'NR==1 { $1=""; sub(/^ /, ""); print }'

Su Solaris utilizzo:

find . -type f -ls|sort -nr -k7|awk 'NR==1{print $7,$11}' #formatted

o

find . -type f -ls | sort -nrk7 | head -1 #unformatted

perché qualsiasi altra cosa pubblicata qui non ha funzionato. Questo troverà il file più grande in $PWDe sottodirectory.

Prova il seguente one-liner (mostra i primi 20 file più grandi):

ls -1Rs | sed -e "s/^ *//" | grep "^[0-9]" | sort -nr | head -n20

o (dimensioni leggibili dall'uomo):

ls -1Rhs | sed -e "s/^ *//" | grep "^[0-9]" | sort -hr | head -n20

Funziona bene sotto Linux / BSD / OSX rispetto ad altre risposte, poiché l' -printfopzione find non esiste su OSX / BSD e statha parametri diversi a seconda del sistema operativo. Tuttavia il secondo comando di lavorare su OSX / BSD correttamente (come sortnon ha -h), installare sortda coreutilso Rimuovi -hda lse utilizzare sort -nrinvece.

Quindi questi alias sono utili da avere nei tuoi file rc :

alias big='du -ah . | sort -rh | head -20'
alias big-files='ls -1Rhs | sed -e "s/^ *//" | grep "^[0-9]" | sort -hr | head -n20'

Prova il seguente comando:

find /your/path -printf "%k %p\n" | sort -g -k 1,1 | awk '{if($1 > 500000) print $1/1024 "MB" " " $2 }' |tail -n 1 

Questo stamperà il nome e la dimensione del file più grandi e più di 500M. Puoi spostare il if($1 > 500000), e stamperà il file più grande nella directory.

du -aS /PATH/TO/folder | sort -rn | head -2 | tail -1

o

du -aS /PATH/TO/folder | sort -rn | awk 'NR==2'

Questo script semplifica la ricerca dei file più grandi per ulteriori azioni. Lo tengo nella mia directory ~ / bin e metto ~ / bin nel mio $ PATH.

#!/usr/bin/env bash
# scriptname: above
# author: Jonathan D. Lettvin, 201401220235

# This finds files of size >= $1 (format ${count}[K|M|G|T], default 10G)
# using a reliable version-independent bash hash to relax find's -size syntax.
# Specifying size using 'T' for Terabytes is supported.
# Output size has units (K|M|G|T) in the left hand output column.

# Example:
#   ubuntu12.04$ above 1T
#   128T /proc/core

# http://stackoverflow.com/questions/1494178/how-to-define-hash-tables-in-bash
# Inspiration for hasch: thanks Adam Katz, Oct 18 2012 00:39
function hasch() { local hasch=`echo "$1" | cksum`; echo "${hasch//[!0-9]}"; }
function usage() { echo "Usage: $0 [{count}{k|K|m|M|g|G|t|T}"; exit 1; }
function arg1() {
    # Translate single arg (if present) into format usable by find.
    count=10; units=G;  # Default find -size argument to 10G.
    size=${count}${units}
    if [ -n "$1" ]; then
        for P in TT tT GG gG MM mM Kk kk; do xlat[`hasch ${P:0:1}`]="${P:1:1}"; done
        units=${xlat[`hasch ${1:(-1)}`]}; count=${1:0:(-1)}
        test -n "$units" || usage
        test -x $(echo "$count" | sed s/[0-9]//g) || usage
        if [ "$units" == "T" ]; then units="G"; let count=$count*1024; fi
        size=${count}${units}
    fi
}
function main() {
    sudo \
        find / -type f -size +$size -exec ls -lh {} \; 2>/dev/null | \
        awk '{ N=$5; fn=$9; for(i=10;i<=NF;i++){fn=fn" "$i};print N " " fn }'
}

arg1 $1
main $size

Questo è un modo molto più semplice per farlo:

ls -l | tr -s " " " " | cut -d " " -f 5,9 | sort -n -r | head -n 1***

E otterrai questo: 8445 examples.desktop

Soluzione Linux: ad esempio, si desidera visualizzare l'elenco di tutti i file / cartelle della directory home (/) in base alla dimensione del file / cartella ( ordine discendente ).

sudo du -xm / | sort -rn | Di Più

Per elencare il file più grande in una cartella

ls -sh /pathFolder | sort -rh | head -n 1

L'output di ls -shè una vista dimensionata se hcomprensibile per le persone del numero di dimensioni del file.

Potresti usare ls -shS /pathFolder | head -n 1. Il più grande Sda lsgià ordina l'elenco dai file più grandi a quelli più piccoli, ma il primo risultato è la somma di tutti i file in quella cartella. Quindi, se vuoi elencare solo il file più grande, un file, devi head -n 2controllare il "risultato della seconda riga" o utilizzare il primo esempio con ls sort head.

ls -alR|awk '{ if ($5 > max) {max=$5;ff=$9}} END {print max "\t" ff;}'