it-swarm.com.de

Wie sortieren Sie die Ausgabe nach Größe?

Wie sortierst du du -sh /dir/* nach Größe? Ich habe eine Seite gelesen, auf der stand, dass | sort -n aber das stimmt offensichtlich nicht. Hier ist ein Beispiel, das falsch ist.

[~]# du -sh /var/* | sort -n
0       /var/mail
1.2M    /var/www
1.8M    /var/tmp
1.9G    /var/named
2.9M    /var/run
4.1G    /var/log
8.0K    /var/account
8.0K    /var/crash
8.0K    /var/cvs
8.0K    /var/games
8.0K    /var/local
8.0K    /var/nis
8.0K    /var/opt
8.0K    /var/preserve
8.0K    /var/racoon
12K     /var/aquota.user
12K     /var/portsentry
16K     /var/ftp
16K     /var/quota.user
20K     /var/yp
24K     /var/db
28K     /var/empty
32K     /var/lock
84K     /var/profiles
224M    /var/netenberg
235M    /var/cpanel
245M    /var/cache
620M    /var/lib
748K    /var/spool
209
xenoterracide

Wenn Sie GNU coreutils (in den meisten Linux-Distributionen üblich) haben, können Sie verwenden

du -sh -- * | sort -h

Die Option -h Sagt sort, dass die Eingabe das vom Menschen lesbare Format ist (Zahl mit Einheit; 1024-basiert, sodass 1023 als weniger als 1 KB betrachtet wird, was mit dem übereinstimmt, was GNU du -h Tut).

Diese Funktion wurde hinzugefügt zu GNU Core Utilities 7.5 im August 2009 .

Hinweis:

Wenn Sie eine ältere Version von Mac OSX verwenden, müssen Sie coreutils mit brew install coreutils , Installieren und dann gsort als Drop-In-Ersatz für sort verwenden.

Neuere Versionen von macOS (auf Mojave verifiziert) unterstützen sort -h Nativ.

268
Shawn J. Goff

Verwenden Sie das Flag -k, um 1K-Blöcke zu zählen, anstatt von Menschen lesbar zu verwenden. Dann haben Sie eine gemeinsame Einheit und können leicht eine numerische Sortierung durchführen.

du -ck | sort -n

Sie benötigen nicht explizit menschliche Einheiten, aber wenn Sie dies getan haben, gibt es eine Reihe von Möglichkeiten, dies zu tun. Viele scheinen die oben beschriebene 1K-Blocktechnik zu verwenden und rufen dann du erneut an.

https://serverfault.com/questions/62411/how-can-i-sort-du-h-output-by-size

Wenn Sie möchten, dass die KB-Einheiten hinzugefügt werden, verwenden Sie:

du -k | sed -e 's_^\([0-9]*\)_\1 KB_' | sort -n
49
pboin

Wenn Sie keine aktuelle Version von GNU coreutils ) haben, können Sie du ohne aufrufen -h, Um eine sortierbare Ausgabe zu erhalten und mit ein wenig Nachbearbeitung eine benutzerfreundliche Ausgabe zu erstellen. Dies hat den Vorteil, dass es auch dann funktioniert, wenn Ihre Version von du nicht über den -h Verfügt. Flagge.

du -k | sort -n | awk '
    function human(x) {
        if (x<1000) {return x} else {x/=1024}
        s="kMGTEPZY";
        while (x>=1000 && length(s)>1)
            {x/=1024; s=substr(s,2)}
        return int(x+0.5) substr(s,1,1)
    }
    {gsub(/^[0-9]+/, human($1)); print}'

Wenn Sie SI-Suffixe möchten (d. H. Vielfache von 1000 anstelle von 1024), ändern Sie 1024 in 1000 im Schleifenkörper while. (Beachten Sie, dass 1000 in der Bedingung vorgesehen ist, sodass Sie beispielsweise 1M Anstelle von 1000k Erhalten.)

Wenn Ihr du eine Option zum Anzeigen von Größen in Bytes hat (z. B. -b Oder -B 1 - beachten Sie, dass dies den Nebeneffekt haben kann, dass die tatsächlichen Dateigrößen anstatt der Festplattennutzung gezählt werden). Fügen Sie am Anfang von s (dh s=" kMGTEPYZ";) ein Leerzeichen hinzu oder fügen Sie am Anfang der Funktion humanif (x<1000) {return x} else {x/=1024} hinzu.

Das Anzeigen einer Dezimalstelle für Zahlen im Bereich von 1 bis 10 bleibt dem Leser als Übung überlassen.

Wenn Sie nicht haben sort -h du kannst das:

du -sh * | sed 's/\([[:digit:]]\)\t/\1B\t/' | sed 's/\(.\t\)/\t\1/' | sed 's/G\t/Z\t/' | sort -n -k 2d,2 -k 1n,1 | sed 's/Z\t/G\t/'

Dies ruft die du-Liste ab, trennt das Suffix und sortiert danach. Da es für <1K kein Suffix gibt, fügt der erste Sed ein B (für Byte) hinzu. Das zweite Sed fügt ein Trennzeichen zwischen der Ziffer und dem Suffix ein. Das dritte sed wandelt G in Z um, so dass es größer als M ist; Wenn Sie Terabyte-Dateien haben, müssen Sie G in Y und T in Z konvertieren. Schließlich sortieren wir nach den beiden Spalten und ersetzen das G-Suffix.

9
Shawn J. Goff

Unter OS X können Sie die erforderlichen Coreutils über Homebrew installieren:

brew install coreutils

Damit haben Sie gsort, einschließlich -h Befehlszeilenparameter.

6
Roland

Dieses kleine Perl-Skript macht den Trick. Speichern Sie es als duh (oder wie auch immer Sie wollen) und rufen Sie es mit duh /dir/*

#!/usr/bin/Perl -w
use strict;

my @line;

sub to_human_readable {
        my ($number) = @_;
        my @postfix = qw( k M G T P );
        my $post;
        my $divide = 1;
        foreach (@postfix) {
                $post = $_;
                last if (($number / ($divide * 1024)) < 1);
                $divide = $divide * 1024;
        }
        $number = int($number/$divide + 0.5);
        return $number . $post;
}

sub trimlengthright {
        my ($txt, $len) = @_;
        if ( length($txt) >= $len ) {
                $txt = substr($txt,0,$len - 1) . " ";
        } else {
                $txt = $txt . " " x ($len - length($txt));
        }
        return $txt;
}

sub trimlengthleft {
        my ($txt, $len) = @_;
        if ( length($txt) >= $len ) {
                $txt = substr($txt,0,$len - 1) . " ";
        } else {
                $txt = " " x ($len - length($txt)) . $txt;
        }
        return $txt;
}

open(DF,"du -ks @ARGV | sort -n |");
while (<DF>) {
        @line = split;
        print &trimlengthleft(&to_human_readable($line[0]),5)," "; # size
        print &trimlengthright($line[1],70),"\n"; # directory
}
close DF;
4
ddeimeke

Da Mac OS X die Option -h Für sort nicht hat, habe ich sed und awk für einen ersten Versuch ausprobiert und gelernt:

du -sk * | sort -g | awk '{ numBytes = $1 * 1024; numUnits = split("B K M G T P", unit); num = numBytes; iUnit = 0; while(num >= 1024 && iUnit + 1 < numUnits) { num = num / 1024; iUnit++; } $1 = sprintf( ((num == 0) ? "%6d%s " : "%6.1f%s "), num, unit[iUnit + 1]); print $0; }'

es ist eine lange Schlange. Erweitert ist es:

du -sk * | sort -g | awk '{ 

    numBytes = $1 * 1024; 
    numUnits = split("B K M G T P", unit); 
    num = numBytes; 
    iUnit = 0; 

    while(num >= 1024 && iUnit + 1 < numUnits) { 
        num = num / 1024; 
        iUnit++; 
    } 

    $1 = sprintf( ((num == 0) ? "%6d%s " : "%6.1f%s "), num, unit[iUnit + 1]);
    print $0; 

}'

Ich habe es unter Mac OS X Mavericks, Yosemite, Ubuntu 2014-04 versucht, wobei awk die Standardeinstellung awk ist (dies ist nawk, da sowohl awk als auch nawk zeigen auf /usr/bin/mawk) Oder gaffen, und alle haben funktioniert.

Hier ist ein Beispiel für die Ausgabe auf einem Mac:

     0B  bar
     0B  foo
   4.0K  wah
  43.0M  Documents
   1.2G  Music
   2.5G  Desktop
   4.7G  Movies
   5.6G  VirtualBox VMs
   9.0G  Dropbox
  11.7G  Library
  21.2G  Pictures
  27.0G  Downloads

anstelle von du -sk * habe ich in der Antwort von @ Stefan gesehen, wo auch die Gesamtsumme angezeigt wird, ohne einen Dateisystem-Mountpunkt zu durchlaufen, indem ich du -skcx * verwendet habe.

4
nonopolarity

Folgendes verwende ich unter Ubuntu 10.04, CentOS 5.5, FreeBSD und Mac OS X.

Ich habe die Idee von www.geekology.co.za/ und earthinfo.org sowie die berüchtigten ducks von "Linux Server Hacks" ausgeliehen "von O'Reilly. Ich passe es immer noch an meine Bedürfnisse an. Dies ist noch in Arbeit (Wie in, ich habe heute Morgen im Zug daran gearbeitet.):

#! /usr/bin/env bash
ducks () {
    du -cks -x | sort -n | while read size fname; do
        for unit in k M G T P E Z Y; do
            if [ $size -lt 1024 ]; then
                echo -e "${size}${unit}\t${fname}"
                break
            fi
            size=$((size/1024))
        done
    done
}
ducks > .ducks && tail .ducks

Hier ist die Ausgabe:

[email protected]:~ $ ducks
32M src
42M .cpan
43M .macports
754M    doc
865M    Work
1G  .Trash
4G  Library
17G Downloads
30G Documents
56G total

[email protected]:~ $
1

In Abwesenheit von GNU sort -h, dies sollte in den meisten UNIX-Umgebungen funktionieren:

join -1 2 -2 2 <(du -sk /dir/* 2>/dev/null | sort -k2,2) <(du -sh /dir/* 2>/dev/null | sort -k2,2) | sort -nk2,2 | awk '{ print $3 "\t" $1 }'
1
friedl.otto

Verrückt werden mit diesem Skript -

$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;}'
1
jaypal singh

Befehl :

du -ah . | sort -k1 -h | tail -n 50

Erklärung :

  • Listengröße aller Dateien/Ordner im aktuellen Verzeichnis rekursiv in lesbarer Form

du -ah .

  • Sortieren Sie die für Menschen lesbare Größe in der ersten Spalte und behalten Sie die größte 50 bei

sort -k1 -h | tail -n 50

0
Rohan Ghige

Das größte ist unten:

du -sh * | sort -h
0
Meskan

Dieser behandelt Dateinamen mit Leerzeichen oder Apostrophen und funktioniert auf Systemen, die xargs -d Oder sort -h Nicht unterstützen:

du -s * | sort -n | cut -f2 | tr '\n' '\0' | xargs -0 -I {} du -sh "{}"

was in ... resultiert:

368K    diskmanagementd
392K    racoon
468K    coreaudiod
472K    securityd
660K    sshd
3.6M    php-fpm
0
Mark Crossfield

Dadurch wird die Ausgabe in absteigender Reihenfolge sortiert:

du -sh /var/* | sort -k 1rn

Dadurch wird die Ausgabe in aufsteigender Reihenfolge sortiert:

du -sh /var/* | sort -k 1n

PS: Dies kann zum Sortieren nach einer beliebigen Spalte verwendet werden, die Spaltenwerte sollten jedoch dasselbe Format haben

0
user5337995

Getestet auf Solaris!

du -kh | sort -nk1 | grep [0-9]K && du -kh | sort -nk1 | grep [0-9]M && du -kh | sort -nk1 | grep [0-9]G

Dadurch werden alle Verzeichnisgrößen rekursiv ausgegeben, unten das größte Verzeichnis in Gigabyte und oben das kleinste in Kilobyte.

0
Chuguniy