Come posso ordinare l'output du -h per dimensione

Ho bisogno di ottenere un elenco di output leggibile dall'uomo.

Tuttavia, dunon ha un'opzione "ordina per dimensione" e il piping su sortnon funziona con la bandiera leggibile dall'uomo.

Ad esempio, eseguendo:

du | sort -n -r 

Emette un utilizzo del disco ordinato per dimensione (decrescente):

du |sort -n -r
65108   .
61508   ./dir3
2056    ./dir4
1032    ./dir1
508     ./dir2

Tuttavia, eseguendolo con la bandiera umana leggibile, non si ordina correttamente:

du -h | sort -n -r

508K    ./dir2
64M     .
61M     ./dir3
2.1M    ./dir4
1.1M    ./dir1

Qualcuno sa un modo per ordinare du -h per dimensione?

A partire da GNU coreutils 7.5 rilasciato nell'agosto 2009, sortconsente un -hparametro, che consente suffissi numerici del tipo prodotto da du -h:

du -hs * | sort -h

Se stai usando un ordinamento che non supporta -h, puoi installare GNU Coreutils. Ad esempio su un Mac OS X precedente:

brew install coreutils
du -hs * | gsort -h

Dal sort manuale :

-h, --human-numeric-sort compare human readable numbers (e.g., 2K 1G)

du | sort -nr | cut -f2- | xargs du -hs

@Douglas Leeder, un'altra risposta: ordina l'output leggibile da du -h usando un altro strumento. Come Perl!

du -h | perl -e 'sub h{%h=(K=>10,M=>20,G=>30);($n,$u)=shift=~/([0-9.]+)(\D)/;
return $n*2**$h{$u}}print sort{h($b)<=>h($a)}<>;'

Dividi su due righe per adattarsi al display. Puoi usarlo in questo modo o renderlo un one-liner, funzionerà in entrambi i modi.

Produzione:

4.5M    .
3.7M    ./colors
372K    ./plugin
128K    ./autoload
100K    ./doc
100K    ./syntax

EDIT: dopo alcune partite di golf a PerlMonks , il risultato finale è il seguente:

perl -e'%h=map{/.\s/;99**(ord$&&7)-$`,$_}`du -h`;die@h{sort%h}'

Esiste uno strumento immensamente utile che uso, chiamato ncdu, progettato per trovare quei fastidiosi file e cartelle con elevato utilizzo del disco e rimuoverli. È basato su console, veloce e leggero e ha pacchetti su tutte le principali distribuzioni.

du -k * | sort -nr | cut -f2 | xargs -d '\n' du -sh

Per quanto posso vedere, hai tre opzioni:

1. Modifica duper ordinare prima della visualizzazione.
2. Modifica sortper supportare le dimensioni umane per l'ordinamento numerico.
3. Post elabora l'output dall'ordinamento per modificare l'output di base in leggibile.

Potresti anche fare du -ke vivere con taglie in KiB.

Per l'opzione 3 è possibile utilizzare il seguente script:

#!/usr/bin/env python

import sys
import re

sizeRe = re.compile(r"^(\d+)(.*)$")

for line in sys.stdin.readlines():
    mo = sizeRe.match(line)
    if mo:
        size = int(mo.group(1))
        if size < 1024:
            size = str(size)+"K"
        elif size < 1024 ** 2:
            size = str(size/1024)+"M"
        else:
            size = str(size/(1024 ** 2))+"G"

        print "%s%s"%(size,mo.group(2))
    else:
        print line

Ho avuto anche quel problema e attualmente sto usando una soluzione alternativa:

du -scBM | sort -n

Ciò non produrrà valori in scala, ma produrrà sempre la dimensione in megabyte. È meno che perfetto, ma per me è meglio di niente (o visualizza la dimensione in byte).

Ho trovato questo post altrove. Pertanto, questo script di shell farà ciò che desideri senza richiamare dututto due volte. Usa awkper convertire i byte grezzi in un formato leggibile dall'uomo. Naturalmente, la formattazione è leggermente diversa (tutto viene stampato con una precisione decimale).

#/bin/bash
du -B1 | sort -nr  |awk '{sum=$1;
hum[1024**3]="G";hum[1024**2]="M";hum[1024]="K";
for (x=1024**3; x>=1024; x/=1024){
        if (sum>=x) { printf "%.1f%s\t\t",sum/x,hum[x];print $2;break
}}}'

L'esecuzione di questo nella mia .vimdirectory produce:

4.4M            .
3.6M            ./colors
372.0K          ./plugin
128.0K          ./autoload
100.0K          ./syntax
100.0K          ./doc

(Spero che 3,6 milioni di combinazioni di colori non siano eccessive.)

Questa versione consente awkdi creare colonne aggiuntive per le chiavi di ordinamento. Chiama solo duuna volta. L'output dovrebbe apparire esattamente come du.

L'ho diviso in più righe, ma può essere ricombinato in una riga.

du -h |
  awk '{printf "%s %08.2f\t%s\n", 
    index("KMG", substr($1, length($1))),
    substr($1, 0, length($1)-1), $0}' |
  sort -r | cut -f2,3

Spiegazione:

• INIZIA - crea una stringa da indicizzare per sostituire 1, 2, 3 con K, M, G per il raggruppamento per unità, se non c'è unità (la dimensione è inferiore a 1K), allora non c'è corrispondenza e viene restituito uno zero (perfetto! )
• stampa i nuovi campi - unità, valore (per far funzionare correttamente l'ordinamento alfa è a zero, lunghezza fissa) e linea originale
• indicizza l'ultimo carattere del campo dimensione
• estrarre la parte numerica della dimensione
• ordina i risultati, scarta le colonne extra

Provalo senza il cutcomando per vedere cosa sta facendo.

Ecco una versione che esegue l'ordinamento all'interno dello script AWK e non ha bisogno di cut:

du -h |
   awk '{idx = sprintf("%s %08.2f %s", 
         index("KMG", substr($1, length($1))),
         substr($1, 0, length($1)-1), $0);
         lines[idx] = $0}
    END {c = asorti(lines, sorted);
         for (i = c; i >= 1; i--)
           print lines[sorted[i]]}'

Ecco un esempio che mostra le directory in una forma riepilogativa più compatta. Gestisce gli spazi nella directory / nomi dei file.

% du -s * | sort -rn | cut -f2- | xargs -d "\n" du -sh

53G  projects
21G  Desktop
7.2G VirtualBox VMs
3.7G db
3.3G SparkleShare
2.2G Dropbox
272M apps
47M  incoming
14M  bin
5.7M rpmbuild
68K  vimdir.tgz

ordina i file per dimensione in MB

du --block-size=MiB --max-depth=1 path | sort -n

Ho un wrapper in pitone semplice ma utile per du chiamato dutop . Si noti che noi (i manutentori di coreutils) stiamo valutando di aggiungere la funzionalità di ordinamento per ordinare direttamente l'output "umano".

Ne ho un altro:

$ du -B1 | sort -nr | perl -MNumber::Bytes::Human=format_bytes -F'\t' -lane 'print format_bytes($F[0])."\t".$F[1]'

Sto iniziando ad apprezzare il perl. Potrebbe essere necessario fare un

$ cpan Number::Bytes::Human

primo. A tutti gli hacker di perl là fuori: Sì, so che la parte di ordinamento può essere eseguita anche in perl. Probabilmente anche la seconda parte.

Questo frammento è stato sfacciato senza vergogna da "Jean-Pierre" da http://www.unix.com/shell-programming-scripting/32555-du-h-sort.html . C'è un modo in cui posso dargli credito?

du -k | sort -nr | awk '
     BEGIN {
        split("KB,MB,GB,TB", Units, ",");
     }
     {
        u = 1;
        while ($1 >= 1024) {
           $1 = $1 / 1024;
           u += 1
        }
        $1 = sprintf("%.1f %s", $1, Units[u]);
        print $0;
     }
    '

Usa il flag "-g"

 -g, --general-numeric-sort
              compare according to general numerical value

E sulla mia directory / usr / local produce output in questo modo:

$ du |sort -g

0   ./lib/site_ruby/1.8/rubygems/digest
20  ./lib/site_ruby/1.8/rubygems/ext
20  ./share/xml
24  ./lib/perl
24  ./share/sgml
44  ./lib/site_ruby/1.8/rubygems/package
44  ./share/mime
52  ./share/icons/hicolor
56  ./share/icons
112 ./share/perl/5.10.0/YAML
132 ./lib/site_ruby/1.8/rubygems/commands
132 ./share/man/man3
136 ./share/man
156 ./share/perl/5.10.0
160 ./share/perl
488 ./share
560 ./lib/site_ruby/1.8/rubygems
604 ./lib/site_ruby/1.8
608 ./lib/site_ruby

Un altro:

du -h | perl -e'
@l{ K, M, G } = ( 1 .. 3 );
print sort {
    ($aa) = $a =~ /(\w)\s+/;
    ($bb) = $b =~ /(\w)\s+/;
    $l{$aa} <=> $l{$bb} || $a <=> $b
  } <>'

Ecco il semplice metodo che utilizzo, un utilizzo delle risorse molto basso e ti offre ciò di cui hai bisogno:

du --max-depth=1 | sort -n | awk 'BEGIN {OFMT = "%.0f"} {print $1/1024,"MB", $2}'

0 MB ./etc
1 MB ./mail
2 MB ./tmp
123 MB ./public_html

Trovato questo online ... sembra funzionare bene

du -sh * | tee /tmp/duout.txt | grep G | sort -rn ; cat /tmp/duout.txt | grep M | sort -rn ; cat /tmp/duout.txt | grep K | sort -rn ; rm /tmp/duout.txt

Ieri ho imparato a meravigliare inventando questo esempio. Ci è voluto del tempo, ma è stato molto divertente e ho imparato a usare awk.

Funziona solo du una volta e ha un output molto simile a du -h

du --max-depth=0 -k * | sort -nr | awk '{ if($1>=1024*1024) {size=$1/1024/1024; unit="G"} else if($1>=1024) {size=$1/1024; unit="M"} else {size=$1; unit="K"}; if(size<10) format="%.1f%s"; else format="%.0f%s"; res=sprintf(format,size,unit); printf "%-8s %s\n",res,$2 }'

Mostra numeri inferiori a 10 con un punto decimale.

du -cka --max-depth = 1 / var / log | ordina -rn | testa -10 | awk '{print ($ 1) / 1024, "MB", $ 2'}

Se è necessario gestire gli spazi, è possibile utilizzare quanto segue

 du -d 1| sort -nr | cut -f2 | sed 's/ /\\ /g' | xargs du -sh

L'istruzione sed aggiuntiva aiuterà ad alleviare i problemi con le cartelle con nomi come Supporto applicazioni

Ecco:

du -sk /var/log/* | sort -rn | awk '{print $2}' | xargs -ia du -hs "a"

http://dev.yorhel.nl/ncdu

comando: ncdu

Navigazione della directory, ordinamento (nome e dimensioni), rappresentazione grafica, lettura umana, ecc ...

Un'altra awksoluzione -

du -k ./* | sort -nr | 
awk '
{split("KB,MB,GB",size,",");}
{x = 1;while ($1 >= 1024) 
{$1 = $1 / 1024;x = x + 1} $1 = sprintf("%-4.2f%s", $1, size[x]); print $0;}'


[jaypal~/Desktop/Reference]$ du -k ./* | sort -nr | awk '{split("KB,MB,GB",size,",");}{x = 1;while ($1 >= 1024) {$1 = $1 / 1024;x = x + 1} $1 = sprintf("%-4.2f%s", $1, size[x]); print $0;}'
15.92MB ./Personal
13.82MB ./Personal/Docs
2.35MB ./Work Docs
1.59MB ./Work Docs/Work
1.46MB ./Personal/Raa
584.00KB ./scan 1.pdf
544.00KB ./Personal/Resume
44.00KB ./Membership.xlsx
16.00KB ./Membership Transmittal Template.xlsx

Stavo usando la soluzione fornita da @ptman, ma una recente modifica del server l'ha resa non più praticabile. Invece, sto usando il seguente script bash:

#!/bin/bash
# File: duf.sh
# list contents of the current directory by increasing 
#+size in human readable format

# for some, "-d 1" will be "--maxdepth=1"
du -k -d 1 | sort -g | awk '
{
if($1<1024)
    printf("%.0f KB\t%s",$1,$2);
else if($1<1024*1024)
    printf("%.1f MB\t%s",$1/1024,$2);
else
    printf("%.1f GB\t%s",$1/1024/1024,$2);
}'

du -s * | ordina -nr | cut -f2 | xargs du -sh

Ci sono molte risposte qui, molte delle quali sono duplicati. Vedo tre tendenze: passare in rassegna un secondo du call, usare un complicato codice shell / awk e usare altre lingue.

Ecco una soluzione conforme a POSIX che utilizza du e awk che dovrebbe funzionare su ogni sistema.

Ho adottato un approccio leggermente diverso, aggiungendo -xper assicurarmi di rimanere sullo stesso filesystem (ho sempre bisogno di questa operazione quando ho poco spazio su disco, quindi perché eliminare le cose che ho montato all'interno di questo albero FS o spostato e symlinked back?) e visualizzazione di unità costanti per facilitare l'analisi visiva. In questo caso, in genere scelgo di non ordinare in modo da poter vedere meglio la struttura gerarchica.

sudo du -x | awk '
  $1 > 2^20 { s=$1; $1=""; printf "%7sG%s\n", sprintf("%.2f",s/2^21), $0 }'

(Poiché si tratta di unità coerenti, si può quindi aggiungere | sort -nse si vuole veramente sorta risultati ndr).

Ciò filtra qualsiasi directory il cui contenuto (cumulativo) non superi i 512 MB e quindi visualizza le dimensioni in gigabyte. Per impostazione predefinita, du utilizza una dimensione di blocco di 512 byte (quindi la condizione di awk di 2 ²⁰ blocchi è 512 MB e il suo divisore 2 ²¹ converte le unità in GB - potremmo usare du -kxcon $1 > 512*1024e s/1024^2per essere più leggibili dall'uomo). All'interno della condizione awk, abbiamo impostato sle dimensioni in modo da poterlo rimuovere dalla linea ( $0). Ciò mantiene il delimitatore (che viene compresso in un singolo spazio), quindi il finale %srappresenta uno spazio e quindi il nome della directory aggregata. %7sallinea la %.2fdimensione GB arrotondata (aumenta a %8sse hai> 10 TB).

A differenza della maggior parte delle soluzioni qui, questo supporta correttamente le directory con spazi nei loro nomi (anche se ogni soluzione, compresa questa, gestirà in modo errato i nomi delle directory che contengono le interruzioni di riga).

Almeno con i soliti strumenti, questo sarà difficile a causa del formato in cui si trovano i numeri leggibili dall'uomo (nota che l'ordinamento fa un "buon lavoro" qui in quanto ordina i numeri - 508, 64, 61, 2, 2 - esso semplicemente non riesco a ordinare i numeri in virgola mobile con un moltiplicatore aggiuntivo).

Vorrei provarlo al contrario: utilizzare l'output di "du | sort -n -r" e successivamente convertire i numeri in formato leggibile dall'uomo con qualche script o programma.

Quello che puoi provare è:

for i in `du -s * | sort -n | cut -f2`
do
  du -h $i;
done

Spero che aiuti.

du | sort -nr | awk '{ cmd = "du -h -d0 "$2"| cut -f1"; cmd | getline human; close(cmd); print human"\t"$2 }'