Wie kann ich die Ausgabe nach Größe sortieren?

Ich brauche eine Liste der von Menschen lesbaren Du-Ausgaben.

Es gibt dujedoch keine Option " Nach Größe sortieren", und die Weiterleitung sortfunktioniert nicht mit dem für Menschen lesbaren Flag.

Zum Beispiel läuft:

du | sort -n -r 

Gibt eine sortierte Datenträgerverwendung nach Größe aus (absteigend):

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

Wenn Sie es jedoch mit dem von Menschen lesbaren Flag ausführen, wird nicht ordnungsgemäß sortiert:

du -h | sort -n -r

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

Kennt jemand eine Möglichkeit, du -h nach Größe zu sortieren ?

Ab GNU Coreutils 7.5, das im August 2009 veröffentlicht wurde, sortist ein -hParameter zulässig, der numerische Suffixe der folgenden Art zulässt du -h:

du -hs * | sort -h

Wenn Sie eine Sortierung verwenden, die nicht unterstützt -h, können Sie GNU Coreutils installieren. ZB auf einem älteren Mac OS X:

brew install coreutils
du -hs * | gsort -h

Aus dem sort Handbuch :

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

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

@Douglas Leeder, noch eine Antwort: Sortiere die lesbare Ausgabe von du -h mit einem anderen Tool. Wie 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)}<>;'

Teilen Sie die Anzeige in zwei Zeilen auf. Sie können es auf diese Weise verwenden oder als Einzeiler verwenden, es funktioniert in beiden Richtungen.

Ausgabe:

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

BEARBEITEN: Nach ein paar Runden Golf bei PerlMonks lautet das Endergebnis wie folgt:

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

Es gibt ein immens nützliches Tool namens ncdu , mit dem sich die lästigen Ordner und Dateien mit hohem Festplattenverbrauch finden und entfernen lassen. Es ist konsolenbasiert, schnell und leicht und enthält Pakete für alle wichtigen Distributionen.

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

Soweit ich sehe, haben Sie drei Möglichkeiten:

1. Ändern Sie dudie Sortierung vor der Anzeige.
2. Ändern Sie sort, um menschliche Größen für die numerische Sortierung zu unterstützen.
3. Verarbeiten Sie die Ausgabe von sort nach, um die Basisausgabe in lesbar zu ändern.

Sie können auch du -kmit Größen in KiB leben.

Für Option 3 können Sie das folgende Skript verwenden:

#!/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

Ich hatte auch dieses Problem und verwende derzeit eine Problemumgehung:

du -scBM | sort -n

Dies erzeugt keine skalierten Werte, sondern immer die Größe in Megabyte. Das ist weniger als perfekt, aber für mich ist es besser als nichts (oder die Größe in Bytes anzeigen).

Habe diesen Beitrag woanders gefunden. Daher wird dieses Shell-Skript tun, was Sie wollen, ohne dualles zweimal aufzurufen . Es nutzt awkdas rohe Bytes auf ein lesbares Format zu konvertieren. Natürlich ist die Formatierung etwas anders (alles wird mit einer Genauigkeit von einer Dezimalstelle gedruckt).

#/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
}}}'

Wenn Sie dies in meinem .vimVerzeichnis ausführen, erhalten Sie:

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

(Ich hoffe, 3.6M Farbschemata sind nicht übermäßig.)

In dieser Version werden awkzusätzliche Spalten für Sortierschlüssel erstellt. Es ruft nur dueinmal an. Die Ausgabe sollte genau so aussehen du.

Ich habe es in mehrere Zeilen aufgeteilt, aber es kann wieder zu einem Einzeiler kombiniert werden.

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

Erläuterung:

• BEGIN - Erstellen Sie einen Index-String, um K, M, G durch 1, 2, 3 für die Gruppierung nach Einheiten zu ersetzen. Wenn keine Einheit vorhanden ist (die Größe ist kleiner als 1 KB), gibt es keine Übereinstimmung und es wird eine Null zurückgegeben (perfekt! )
• Drucken Sie die neuen Felder - Einheit, Wert (damit die Alpha-Sortierung ordnungsgemäß funktioniert, ist sie mit Nullen aufgefüllt und hat eine feste Länge) und die ursprüngliche Zeile
• Indizieren Sie das letzte Zeichen des Größenfelds
• Ziehen Sie den numerischen Teil der Größe heraus
• Sortieren Sie die Ergebnisse und verwerfen Sie die zusätzlichen Spalten

Versuchen Sie es ohne den cutBefehl, um zu sehen, was es tut.

Hier ist eine Version, die das Sortieren innerhalb des AWK-Skripts übernimmt und nicht benötigt 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]]}'

Hier ist ein Beispiel, das die Verzeichnisse in kompakterer, zusammengefasster Form zeigt. Es behandelt Leerzeichen in Verzeichnis / Dateinamen.

% 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

Dateien nach Größe in MB sortieren

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

Ich habe einen einfachen, aber nützlichen Python-Wrapper für du namens dutop . Beachten Sie, dass wir (die Betreuer von coreutils) erwägen, die Funktion zum Sortieren hinzuzufügen, um die "menschliche" Ausgabe direkt zu sortieren.

Habe noch einen:

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

Ich fange an, Perl zu mögen. Möglicherweise müssen Sie eine

$ cpan Number::Bytes::Human

zuerst. An alle Perl-Hacker: Ja, ich weiß, dass der Sortiervorgang auch in Perl durchgeführt werden kann. Wahrscheinlich auch der Du-Teil.

Dieser Ausschnitt wurde unverschämt aus 'Jean-Pierre' von http://www.unix.com/shell-programming-scripting/32555-du-h-sort.html entnommen . Gibt es eine Möglichkeit, ihn besser zu würdigen?

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

Verwenden Sie das Flag "-g"

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

Und in meinem / usr / local-Verzeichnis wird folgende Ausgabe erzeugt:

$ 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

Noch einer:

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

Hier ist die einfache Methode, die ich verwende, die sehr wenig Ressourcen verbraucht und Ihnen das bietet, was Sie brauchen:

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

Fand dieses online ... scheint in Ordnung zu sein

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

Ich habe awk gelernt, als ich gestern dieses Beispiel erfunden habe. Es hat einige Zeit gedauert, aber es hat großen Spaß gemacht und ich habe gelernt, wie man awk benutzt.

Es wird nur einmal ausgeführt und hat eine Ausgabe, die der von du -h sehr ähnlich ist

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

Es zeigt Zahlen unter 10 mit einem Dezimalpunkt.

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

Wenn Sie mit Leerzeichen umgehen müssen, können Sie Folgendes verwenden

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

Die zusätzliche sed-Anweisung hilft, Probleme mit Ordnern mit Namen wie Application Support zu beheben

Voilà:

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

http://dev.yorhel.nl/ncdu

Befehl: ncdu

Verzeichnisnavigation, Sortierung (Name und Größe), grafische Darstellung, lesbar, usw.

Eine andere awkLösung -

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

Ich hatte die von @ptman bereitgestellte Lösung verwendet, aber eine kürzliche Serveränderung machte sie nicht mehr brauchbar. Stattdessen verwende ich das folgende Bash-Skript:

#!/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 * | sort -nr | cut -f2 | xargs du -sh

Hier gibt es viele Antworten, von denen viele Duplikate sind. Ich sehe drei Trends: Weiterleiten durch einen zweiten Aufruf, Verwenden von kompliziertem Shell- / AWK-Code und Verwenden anderer Sprachen.

Hier ist eine POSIX-kompatible Lösung mit du und awk , die auf jedem System funktionieren sollte.

Ich habe einen etwas anderen Ansatz gewählt, um -xsicherzustellen, dass wir auf demselben Dateisystem bleiben (ich brauche diesen Vorgang immer nur, wenn ich nur wenig Speicherplatz habe. Warum sollte ich also Dinge aussortieren, die ich in diesen FS-Baum eingebunden oder verschoben habe?) Symlinked Back?) und Anzeige konstanter Einheiten, um das visuelle Parsen zu vereinfachen. In diesem Fall entscheide ich mich normalerweise, nicht zu sortieren, um die hierarchische Struktur besser erkennen zu können.

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

(Da diese Einheit konsistent ist, können Sie sie anhängen, | sort -nwenn Sie wirklich sortierte Ergebnisse wünschen .)

Dadurch werden alle Verzeichnisse herausgefiltert, deren (kumulativer) Inhalt 512 MB nicht überschreitet, und anschließend werden Größen in Gigabyte angezeigt. Standardmäßig verwendet du eine Blockgröße von 512 Byte (daher beträgt der awk-Zustand von 2 ²⁰ Blöcken 512 MB, und sein 2 ^21- Divisor wandelt die Einheiten in GB um - wir könnten es du -kxmit $1 > 512*1024und verwenden s/1024^2, um besser lesbar zu sein). Innerhalb der awk-Bedingung stellen wir sdie Größe ein, damit wir sie aus der Zeile entfernen können ( $0). Dadurch bleibt das Trennzeichen (das auf ein einzelnes Leerzeichen reduziert ist) erhalten, sodass das Finale %sein Leerzeichen und anschließend den Namen des aggregierten Verzeichnisses darstellt. %7srichtet die gerundete %.2fGB-Größe aus (erhöhen auf %8s> 10 TB).

Im Gegensatz zu den meisten Lösungen werden hier Verzeichnisse mit Leerzeichen im Namen ordnungsgemäß unterstützt (obwohl jede Lösung, einschließlich dieser, Verzeichnisnamen mit Zeilenumbrüchen falsch behandelt).

Zumindest mit den üblichen Tools wird dies aufgrund des Formats der lesbaren Zahlen schwierig sein (beachten Sie, dass sort hier einen "guten Job" macht, da es die Zahlen sortiert - 508, 64, 61, 2, 2 - it Fließkommazahlen können nur nicht mit einem zusätzlichen Multiplikator sortiert werden.

Ich würde es anders herum versuchen - verwende die Ausgabe von "du | sort -n -r" und konvertiere die Zahlen anschließend mit einem Skript oder Programm in ein für Menschen lesbares Format.

Was Sie versuchen können, ist:

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

Ich hoffe, das hilft.

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