Usando ls per elencare le directory e le loro dimensioni totali

È possibile utilizzare lsin Unix per elencare la dimensione totale di una sottodirectory e tutto il suo contenuto al contrario del solito 4Kche (presumo) sia solo il file di directory stesso?

total 12K
drwxrwxr-x  6 *** *** 4.0K 2009-06-19 10:10 branches
drwxrwxr-x 13 *** *** 4.0K 2009-06-19 10:52 tags
drwxrwxr-x 16 *** *** 4.0K 2009-06-19 10:02 trunk

Dopo aver setacciato le pagine man, vengo vuoto.

Prova qualcosa del tipo:

du -sh *

versione corta di:

du --summarize --human-readable *

Spiegazione:

du: D isk U sage

-s: Visualizza un riepilogo per ciascun file specificato. (Equivalente a -d 0)

-h: Output "leggibile dall'uomo". Usa suffissi unità: B yte , K ibibyte (KiB), M ebibyte (MiB), G ibibyte (GiB), T ebibyte (TiB) e P ebibyte (PiB). (BASE2)

du -sk * | sort -nordinerà le cartelle per dimensione. Utile quando si desidera liberare spazio ..

du -sh * | sort -h

Questo verrà visualizzato in un formato leggibile dall'uomo.

Per elencare le directory più grandi dalla directory corrente in formato leggibile dall'uomo:

du -sh * | sort -hr

Può essere un modo migliore per limitare il numero di righe

du -sh * | sort -hr | head -n10

Dove è possibile aumentare il suffisso del -nflag per limitare il numero di righe elencate

Campione:

[~]$ du -sh * | sort -hr
48M app
11M lib
6.7M    Vendor
1.1M    composer.phar
488K    phpcs.phar
488K    phpcbf.phar
72K doc
16K nbproject
8.0K    composer.lock
4.0K    README.md

Rende più comodo leggere :)

Per visualizzarlo in ls -lhformato, utilizzare:

(du -sh ./*; ls -lh --color=no) | awk '{ if($1 == "total") {X = 1} else if (!X) {SIZES[$2] = $1} else { sub($5 "[ ]*", sprintf("%-7s ", SIZES["./" $9]), $0); print $0} }'

Codice Awk spiegato:

if($1 == "total") { // Set X when start of ls is detected
  X = 1 
} else if (!X) { // Until X is set, collect the sizes from `du`
  SIZES[$2] = $1
} else {
  // Replace the size on current current line (with alignment)
  sub($5 "[ ]*", sprintf("%-7s ", SIZES["./" $9]), $0); 
  print $0
}

Uscita campione:

drwxr-xr-x 2 root     root 4.0K    Feb 12 16:43 cgi-bin
drwxrws--- 6 root     www  20M     Feb 18 11:07 document_root
drwxr-xr-x 3 root     root 1.3M    Feb 18 00:18 icons
drwxrwsr-x 2 localusr www  8.0K    Dec 27 01:23 passwd

Il comando che vuoi è 'du -sk' du = "utilizzo del disco"

Il flag -k fornisce l'output in kilobyte, anziché il valore predefinito dei settori del disco (blocchi da 512 byte).

Il flag -s elenca solo le cose nella directory di livello superiore (ovvero, la directory corrente, per impostazione predefinita, o la directory specificata nella riga di comando). È strano che du abbia il comportamento opposto di ls in questo senso. Per impostazione predefinita, du fornirà in modo ricorsivo l'utilizzo del disco di ciascuna sottodirectory. Al contrario, ls fornirà solo i file di elenco nella directory specificata. (ls -R ti dà un comportamento ricorsivo.)

Inserisci questa dichiarazione della funzione di shell negli script di inizializzazione della shell:

function duls {
    paste <( du -hs -- "$@" | cut -f1 ) <( ls -ld -- "$@" )
}

L'ho chiamato dulsperché mostra l'output di entrambi due ls(in quell'ordine):

$ duls
210M    drwxr-xr-x  21 kk  staff  714 Jun 15 09:32 .

$ duls *
 36K    -rw-r--r--   1 kk  staff    35147 Jun  9 16:03 COPYING
8.0K    -rw-r--r--   1 kk  staff     6962 Jun  9 16:03 INSTALL
 28K    -rw-r--r--   1 kk  staff    24816 Jun 10 13:26 Makefile
4.0K    -rw-r--r--   1 kk  staff       75 Jun  9 16:03 Makefile.am
 24K    -rw-r--r--   1 kk  staff    24473 Jun 10 13:26 Makefile.in
4.0K    -rw-r--r--   1 kk  staff     1689 Jun  9 16:03 README
120K    -rw-r--r--   1 kk  staff   121585 Jun 10 13:26 aclocal.m4
684K    drwxr-xr-x   7 kk  staff      238 Jun 10 13:26 autom4te.cache
128K    drwxr-xr-x   8 kk  staff      272 Jun  9 16:03 build
 60K    -rw-r--r--   1 kk  staff    60083 Jun 10 13:26 config.log
 36K    -rwxr-xr-x   1 kk  staff    34716 Jun 10 13:26 config.status
264K    -rwxr-xr-x   1 kk  staff   266637 Jun 10 13:26 configure
8.0K    -rw-r--r--   1 kk  staff     4280 Jun 10 13:25 configure.ac
7.0M    drwxr-xr-x   8 kk  staff      272 Jun 10 13:26 doc
2.3M    drwxr-xr-x  28 kk  staff      952 Jun 10 13:26 examples
6.2M    -rw-r--r--   1 kk  staff  6505797 Jun 15 09:32 mrbayes-3.2.7-dev.tar.gz
 11M    drwxr-xr-x  42 kk  staff     1428 Jun 10 13:26 src

$ duls doc
7.0M    drwxr-xr-x  8 kk  staff  272 Jun 10 13:26 doc

$ duls [bM]*
 28K    -rw-r--r--  1 kk  staff  24816 Jun 10 13:26 Makefile
4.0K    -rw-r--r--  1 kk  staff     75 Jun  9 16:03 Makefile.am
 24K    -rw-r--r--  1 kk  staff  24473 Jun 10 13:26 Makefile.in
128K    drwxr-xr-x  8 kk  staff    272 Jun  9 16:03 build

Spiegazione:

L' pasteutilità crea colonne dal suo input in base alle specifiche fornite. Dati due file di input, li mette fianco a fianco, con una scheda come separatore.

Gli diamo l'output di du -hs -- "$@" | cut -f1come primo file (flusso di input davvero) e l'output di ls -ld -- "$@"come secondo file.

Nella funzione, "$@" valuterà l'elenco di tutti gli argomenti della riga di comando, ciascuno tra virgolette. Comprenderà quindi personaggi sconvolgenti e nomi di percorsi con spazi ecc.

I doppi minus ( --) segnalano la fine delle opzioni della riga di comando a due ls. Senza questi, dire duls -lsarebbe confuso due qualsiasi opzione per duciò lsnon avrebbe confondere ls(e le opzioni che esistono in entrambe le utility potrebbero non significare la stessa cosa, e sarebbe un bel casino).

Il cutdopo duelimina semplicemente la prima colonna didu -hs dell'output (le dimensioni).

Ho deciso di mettere il du output a sinistra, altrimenti avrei dovuto gestire una colonna traballante a destra (a causa della diversa lunghezza dei nomi dei file).

Il comando non accetterà i flag della riga di comando.

Questo è stato testato in entrambi bashe in ksh93. Non funzionerà con /bin/sh.

Invece uso sempre du -sk( -kflag che mostra la dimensione del file in kilobyte).

du -h --max-depth=1 . | sort -n -r

ncdu ncurses du

Questa fantastica utility CLI ti consente di trovare facilmente i file e le directory di grandi dimensioni in modo interattivo.

Ad esempio, dall'interno dell'albero di un noto progetto facciamo:

sudo apt-get install ncdu
ncdu

Il risultato è:

Quindi, inserisco in basso a destra sulla tastiera per accedere alla /driverscartella e vedo:

ncdu calcola ricorsivamente le dimensioni dei file solo una volta all'avvio per l'intero albero, quindi è efficiente.

"Utilizzo totale del disco" vs "Dimensione apparente" è analogo a du, e l'ho spiegato a: perché l'output di `du` spesso è così diverso da` du -b`

Pagina iniziale del progetto: https://dev.yorhel.nl/ncdu

Domande correlate:

• /unix/67806/how-to-recursively-find-the-amount-stored-in-directory/67808
• /unix/125429/tracking-down-where-disk-space-has-gone-on-linux
• /ubuntu/57603/how-to-list-recursive-file-sizes-of-files-and-directories-in-a-directory
• /server/43296/how-does-one-find-which-files-are-taking-up-80-of-the-space-on-a-linux-webserve

Testato in Ubuntu 16.04.

ncdu utilizzo non interattivo

Un'altra caratteristica interessante di ncdu è che puoi prima scaricare le dimensioni in un formato JSON e poi riutilizzarle.

Ad esempio, per generare l'esecuzione del file:

ncdu -o ncdu.json

e poi esaminalo in modo interattivo con:

ncdu -f ncdu.json

Questo è molto utile se hai a che fare con un filesystem molto grande e lento come NFS.

In questo modo, puoi prima esportare solo una volta, il che può richiedere ore, quindi esplorare i file, uscire, esplorare di nuovo, ecc.

Il formato di output è solo JSON, quindi è facile riutilizzarlo anche con altri programmi, ad esempio:

ncdu -o -  | python -m json.tool | less

rivela una semplice struttura di dati dell'albero delle directory:

[
    1,
    0,
    {
        "progname": "ncdu",
        "progver": "1.12",
        "timestamp": 1562151680
    },
    [
        {
            "asize": 4096,
            "dev": 2065,
            "dsize": 4096,
            "ino": 9838037,
            "name": "/work/linux-kernel-module-cheat/submodules/linux"
        },
        {
            "asize": 1513,
            "dsize": 4096,
            "ino": 9856660,
            "name": "Kbuild"
        },
        [
            {
                "asize": 4096,
                "dsize": 4096,
                "ino": 10101519,
                "name": "net"
            },
            [
                {
                    "asize": 4096,
                    "dsize": 4096,
                    "ino": 11417591,
                    "name": "l2tp"
                },
                {
                    "asize": 48173,
                    "dsize": 49152,
                    "ino": 11418744,
                    "name": "l2tp_core.c"
                },

Testato su Ubuntu 18.04.

du -sch * nella stessa directory.

Questo è quello che mi piace

aggiornamento : il precedente non mi piaceva perché non mostrava i file nella directory corrente, elencava solo le directory.

Esempio di output per /varsu Ubuntu:

sudo du -hDaxd1 /var | sort -h | tail -n10

4.0K    /var/lock
4.0K    /var/run
4.0K    /var/www
12K     /var/spool
3.7M    /var/backups
33M     /var/log
45M     /var/webmin
231M    /var/cache
1.4G    /var/lib
1.7G    /var

Questi sono tutti ottimi suggerimenti, ma quello che uso è:

du -ksh * | sort -n -r

-ksh si assicura che i file e le cartelle siano elencati in un formato leggibile dall'uomo e in megabyte, kilobyte, ecc. Quindi li si ordina numericamente e si inverte l'ordinamento in modo da mettere per primi quelli più grandi.

L'unico aspetto negativo di questo comando è che il computer non sa che Gigabyte è più grande di Megabyte, quindi ordinerà solo per numeri e troverai spesso elenchi come questo:

120K
12M
4G

Stai solo attento a guardare l'unità.

Questo comando funziona anche su Mac (mentre sort -hnon lo fa ad esempio).

du -S

du hanno un'altra utile opzione: -S, --separate-dirsraccontare du non includere le dimensioni delle sottodirectory - utile in alcune occasioni.

Esempio 1: mostra solo le dimensioni del file in una directory:

du -Sh  * 
3,1G    10/CR2
280M    10

Esempio 2: mostra le dimensioni e le sottodirectory dei file nella directory:

du -h  * 
3,1G    10/CR2 
3,4G    10

du -sm * | ordina -nr

Uscita per dimensione

guarda il ducomando per quello

solo un avvertimento, se si desidera confrontare le dimensioni dei file. du produce risultati diversi a seconda del file system, della dimensione del blocco, ....

È possibile che le dimensioni dei file siano diverse, ad esempio confrontando la stessa directory sul disco rigido locale e un dispositivo di archiviazione di massa USB. Uso il seguente script, incluso ls per riassumere le dimensioni della directory. Il risultato è in byte che tengono conto di tutte le sottodirectory.

echo "[GetFileSize.sh] target directory: \"$1\""

iRetValue=0

uiLength=$(expr length "$1")
if [ $uiLength -lt 2 ]; then
  echo "[GetFileSize.sh] invalid target directory: \"$1\" - exiting!"
  iRetValue=-1
else
  echo "[GetFileSize.sh] computing size of files..."

  # use ls to compute total size of all files - skip directories as they may
  # show different sizes, depending on block size of target disk / file system
  uiTotalSize=$(ls -l -R $1 | grep -v ^d | awk '{total+=$5;} END {print total;}')
  uiLength=$(expr length "$uiTotalSize")
  if [ $uiLength -lt 1 ]; then
    uiTotalSize=0
  fi
  echo -e "[GetFileSize.sh] total target file size: \"$uiTotalSize\""

fi

exit "$iRetValue"

Per visualizzare ricorsivamente le dimensioni dei file e delle sottodirectory della directory corrente:

du -h .

Per visualizzare le stesse informazioni sulle dimensioni ma senza stampare ricorsivamente le loro sottodirectory (che possono essere un elenco enorme), basta usare l' opzione --max-depth :

du -h --max-depth=1 .

Per un po ', ho usato Nautilus (sul desktop di Gnome su RHEL 6.0) per eliminare i file nella mia cartella home invece di usare il rmcomando in bash. Di conseguenza, la dimensione totale indicata da

du -sh

non corrisponde alla somma dell'utilizzo del disco di ogni sottodirectory, quando l'ho usato

du -sh *

Mi ci è voluto un po 'per capire che Nautilus invia i file eliminati nella sua cartella Cestino e quella cartella non è elencata nel du -sh *comando. Quindi, volevo solo condividere questo, nel caso qualcuno avesse affrontato lo stesso problema.

Hmm, il modo migliore è usare questo comando:

du -h -x / | sort -hr >> /home/log_size.txt

Quindi sarai in grado di ottenere cartelle di tutte le dimensioni su tutto il tuo server. Facile aiutarti a trovare le taglie più grandi.

Quanto segue è facile da ricordare

ls -ltrapR

elenca i contenuti della directory

-l utilizzo di un formato di elenco lungo

-t ordina per ora di modifica, prima il più recente

-r, - inverte l'ordine inverso durante l'ordinamento

-a, --all non ignorano le voci che iniziano con.

-p, --indicator-style = accodamento / indicatore barra alle directory

-R, - elenco ricorsivo delle sottodirectory ricorsivamente

https://explainshell.com/explain?cmd=ls+-ltrapR

Se si desidera un maggiore controllo su sizecui si desidera elencare le directory, è possibile utilizzare l'opzione threshold( -t) come in:

$ du -ht 1000000000 | sort --reverse

du- disk usage
h - formato leggibile dall'uomo
t - dimensione della soglia

Qui, vogliamo elencare tutte le directory di dimensioni superiori a 1 GB.

$ du -ht 1G | sort --reverse

Spiegazione :

Le unità descritte nel wiki sono le seguenti:

K, M, G, T, P, E, Z, Y (potenze di 1024) o
KB, MB, GB, TB, PB, EB, ZB, YB (potenze di 1000).

Ho riscontrato un problema simile a quello descritto da Martin Wilde, nel mio caso confrontando la stessa directory su due server diversi dopo il mirroring con rsync.

Invece di usare uno script ho aggiunto la -bbandiera alla duquale conta la dimensione in byte e, per quanto posso determinare, ho eliminato le differenze sui due server. È ancora possibile utilizzare -s -hper ottenere un risultato comprensibile.

inserire nello script init come .bashrc ... regolare def come necessario.

duh() {
  # shows disk utilization for a path and depth level
  path="${1:-$PWD}"
  level="${2:-0}"
  du "$path" -h --max-depth="$level"
}

digitare "ls -ltrh / path_to_directory"