Wie sortieren Sie Ihre Ausgabe nach Größe?

Wie sortieren Sie du -sh /dir/*nach Größe? Ich habe eine Seite gelesen, auf der die Verwendung angegeben ist, | sort -naber das ist offensichtlich nicht richtig. Hier ist ein falsches Beispiel.

[~]# 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

Wenn Sie GNU-Coreutils haben (die in den meisten Linux-Distributionen üblich sind), können Sie diese verwenden

du -sh -- * | sort -h

Die -hOption gibt an, sortdass die Eingabe vom Menschen lesbar ist (Zahl mit Einheit; 1024-basiert, sodass 1023 als weniger als 1 KB angesehen wird, was dem entspricht, was GNU du -htut).

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

Hinweis:

Wenn Sie eine ältere Version von Mac OSX verwenden, müssen Sie coreutils mit brew install coreutils，installieren und dann gsortals Ersatz für verwenden sort.

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

Verwenden Sie das Flag -k, um 1-KByte-Blöcke anstelle von lesbaren Blöcken zu zählen. Dann haben Sie eine gemeinsame Einheit und können ganz einfach eine numerische Sortierung durchführen.

du -ck | sort -n

Sie brauchen nicht explizit menschliche Einheiten, aber wenn ja, dann gibt es eine Reihe von Möglichkeiten, dies zu tun. Viele scheinen die oben beschriebene 1K-Blocktechnik zu verwenden und dann einen zweiten Aufruf an du zu senden.

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

Wenn Sie die hinzugefügten KB-Einheiten sehen möchten, verwenden Sie:

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

Wenn Sie keine neuere Version von GNU coreutils haben , können Sie duohne Aufruf -hsortierbare Ausgabe erhalten und mit ein wenig Nachbearbeitung eine benutzerfreundliche Ausgabe erzeugen. Dies hat den Vorteil, dass es funktioniert, auch wenn Ihre Version von dudie -hFlagge nicht hat .

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 (dh ein Vielfaches von 1000 anstelle von 1024) wünschen, ändern Sie 1024 in 1000 im whileSchleifenkörper. (Beachten Sie, dass 1000 in der Bedingung vorgesehen ist, so dass Sie zB 1Meher als erhalten 1000k.)

Wenn Sie dudie Option zum Anzeigen von Größen in Byte haben (z. B. -boder -B 1- Beachten Sie, dass dies den Nebeneffekt haben kann, dass die tatsächlichen Dateigrößen anstelle der Festplattennutzung gezählt werden), fügen Sie am Anfang von s(dh s=" kMGTEPYZ";) ein Leerzeichen oder if (x<1000) {return x} else {x/=1024}am Anfang von (dh ) ein die humanFunktion.

Die Anzeige einer Dezimalstelle für Zahlen im Bereich von 1 bis 10 wird dem Leser als Übung überlassen.

Wenn Sie nicht haben sort -h, können Sie dies tun:

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 <1 KB kein Suffix gibt, fügt der erste sed ein B (für Byte) hinzu. Der zweite Satz 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 dann das Suffix G.

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

brew install coreutils

Damit haben Sie gsort, die den -hBefehlszeilenparameter enthält .

Dieses kleine Perl-Skript erledigt den Trick. Speichern Sie es als duh(oder was auch immer Sie wollen) und rufen Sie es mitduh /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;

Da Mac OS X nicht die -hOption für hat sort, habe ich sedund awkfür einen ersten Versuch versucht 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 und Ubuntu 2014-04 mit awkder Standardeinstellung awk( nawkda beide awkund auf nawkzeigen /usr/bin/mawk) oder gawk versucht, 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

Stattdessen habe du -sk *ich in @ Stefans Antwort gesehen, wo auch die Gesamtsumme angezeigt wird, und zwar ohne einen Dateisystem-Mount-Punkt zu durchlaufendu -skcx *

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 Enten von "Linux Server Hacks" von O'Reilly ausgeliehen. 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:

stefan@darwin:~ $ ducks
32M src
42M .cpan
43M .macports
754M    doc
865M    Work
1G  .Trash
4G  Library
17G Downloads
30G Documents
56G total

stefan@darwin:~ $

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;}'

In Abwesenheit von GNU sort -hsollte dies 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 }'

Dieser behandelt Dateinamen mit Leerzeichen oder Apostrophen und funktioniert auf Systemen, die Folgendes nicht unterstützen xargs -doder sort -h:

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

was in ... endet:

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

Dadurch wird die Ausgabe in absteigender Reihenfolge der Größe sortiert:

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

Dadurch wird die Ausgabe in aufsteigender Reihenfolge der Größe sortiert:

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

PS: Dies kann verwendet werden, um nach jeder Spalte zu sortieren, aber die Spaltenwerte sollten dasselbe Format haben

Getestet unter 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 wird das größte Verzeichnis in Gigabyte und oben das kleinste in Kilobyte angezeigt.

Das größte ist unten:

du -sh * | sort -h

Befehl:

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

Erläuterung:

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

du -ah .

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

sort -k1 -h | tail -n 50

Sortieren nach Größe in MB

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

Dieses Skript ist noch einfacher:

for i in G M K; do du -h -d1 / | grep [0-9]$i | sort -n; done

für OSX

du -h -k  {PATH} | sort -n