How can I sort du -h output by size

843

269

I need to get a list of human readable du output.

However, du does not have a "sort by size" option, and piping to sort doesn't work with the human readable flag.

For example, running:

du | sort -n -r 

Outputs a sorted disk usage by size (descending):

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

However, running it with the human readable flag, does not sort properly:

du -h | sort -n -r

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

Does anyone know of a way to sort du -h by size?

Tom Feiner

Posted 2009-02-25T13:42:42.613

Reputation: 6 270

Have you seen this one? https://unix.stackexchange.com/questions/4681/how-do-you-sort-du-output-by-size It is a near duplicate and is worth gold. You do a normal du but add the -h to the sort command. You can add -rh so the largest are first in the file, otherwise you need tail to see the space hogs.

– SDsolar – 2017-08-17T08:32:11.390

I did not expect such a question to be so popular when I googled this. – Mateen Ulhaq – 2018-01-27T11:53:29.123

Heh ... Funny you should ask, as this has been annoying me for ... well over a year at least. Last week I downloaded the code to GNU coreutils (of which sort is a part), and had a look, but decided it would take a bit more time than I had on my hands to patch ... Anyone? :) – unwind – 2009-02-25T13:46:14.227

Here's a much related question: http://serverfault.com/q/737537/35034

– cregox – 2015-11-19T14:15:02.450

Answers

1 169

As of GNU coreutils 7.5 released in August 2009, sort allows a -h parameter, which allows numeric suffixes of the kind produced by du -h:

du -hs * | sort -h

If you are using a sort that does not support -h, you can install GNU Coreutils. E.g. on an older Mac OS X:

brew install coreutils
du -hs * | gsort -h

From sort manual:

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

ptman

Posted 2009-02-25T13:42:42.613

Reputation: 18 852

Standard du on OS X does not support the suggested options, but the one from coreutils does (gdu)

gdu -hs * | gsort -h – pojo – 2016-09-02T12:34:20.757

1

The du(1) man page on Mac OS X 10.9 claims that du supports -h

– ptman – 2016-09-02T12:45:06.950

For future Google users like myself, if you want to use this answer's command but sort by size descending instead of ascending, you just need the -r option for size.

To scroll a list of the largest stuff, use du -hs * | sort -hr | less. – Mike Turley – 2018-02-25T17:20:22.380

This solution does not work on hidden directories that start with a "." like ".git" – giorgio79 – 2018-05-22T18:15:04.740

1@giorgio79 in that case, use * .??* – ptman – 2018-05-22T19:33:39.230

I use du -sh ./* | sort -g cause -h is not supported on BusyBox v1.27.2 – vladkras – 2018-05-23T12:05:08.523

2

The relevant section of the manual: http://www.gnu.org/software/coreutils/manual/coreutils.html#sort-invocation

– wodow – 2011-02-09T11:13:35.270

this is clearly the right answer on modern systems. Thanks! – simon – 2011-03-03T03:36:50.340

27Easy to install on OS X with homebrew -- brew install coreutils. – Richard Poirier – 2011-05-01T18:53:29.533

wow, thanks. Much better thank my evergreen du -sk * | sort -n – ThorstenS – 2011-12-22T07:13:10.733

36Good one! I personally always did du -BM | sort -nr as a workaround - it is human readable enough, and it is sorted, if anyone is stuck with older coreutils. – chutz – 2012-05-24T09:06:25.153

short and sweet :) – Zhanger – 2012-05-31T06:11:05.603

29If using on OSX via Homebrew, note that you'll now need to use gsort rather than sort: du -hs * | gsort -h – Brian Cline – 2013-12-16T08:45:53.190

@chutz, that puts 168K before 104M. – Paul Draper – 2014-02-01T08:41:27.100

2@PaulDraper, du -BM prints everything in megabytes, so a file that is 168K would actually display as 0M. Unless there is some other version discrepancy I am not aware of. My version of du only shows integer megabyte values. – chutz – 2014-02-01T15:12:22.557

@chutz, yes. du -sBM * | sort -nr does work. – Paul Draper – 2014-02-01T18:18:22.307

You can install the GNU coreutils using MacPorts as described [here](http://tunafreedolphin.com/?p=416].

– jvriesem – 2014-10-13T20:49:34.933

If using on FreeBSD, try gsort instead sort. – Vladislav – 2015-07-21T02:26:26.647

The way sort -h seems to work is to sort by the suffix first, and then by the numeric value. e.g. 2000 is deemed to be less than 1K. This would be fine in most autogenerated listings though, where a smaller number will never have a larger suffix then a larger number. – mwfearnley – 2015-09-24T07:46:32.930

83

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

cadrian

Posted 2009-02-25T13:42:42.613

Reputation: 862

3Ugly, but cross-platform :). – voretaq7 – 2011-11-29T23:06:07.820

46And it'll do a huge amount of duplicate counting. – Douglas Leeder – 2009-02-25T13:55:27.260

it would help if you explain why that works?? – hasen – 2009-02-25T14:10:38.287

1First it does the normal du - then for each entry it recalculates the size just to print it in human readable form. – Douglas Leeder – 2009-02-25T14:22:51.440

6@Douglas Leeder: you are right for the duplicate counting, but think that the second du does not start from cold cache (thanks to the OS)

@hasen j: xargs is a very useful command, it splits its stdin and feeds it as arguments to the given command – cadrian – 2009-02-25T14:52:45.017

Don't really care about reputation score, but I am a bit confused as to why this answer has 12 votes when my more or less identical answer below has none. – None – 2009-02-25T20:46:14.543

4Chris's is actually superior since it works with paths containing whitespace. Throwing a vote your way, buddy. – rbright – 2009-02-25T22:45:34.663

Two reasons: most folks just vote for the first good answer they see, and secondly, many people don't know what the -k option to du does. – Michael Kohne – 2009-09-02T19:52:04.463

59

@Douglas Leeder, one more answer: Sort the human-readable output from du -h using another tool. Like 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)}<>;'

Split onto two lines to fit the display. You can use it this way or make it a one-liner, it'll work either way.

Output:

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

EDIT: After a few rounds of golf over at PerlMonks, the final result is the following:

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

Adam Bellaire

Posted 2009-02-25T13:42:42.613

Reputation: 905

works on ubuntu! – marinara – 2012-04-26T08:22:15.903

2Your short version outputs on stderr because of the die can you change it to make it output on stdout? – Dennis Williamson – 2009-09-04T16:16:03.433

2Change the die to a print and it will go to stdout. It's just two more characters. – Adam Bellaire – 2009-09-09T17:55:59.717

impressive perl hackistry – nandoP – 2013-11-13T05:00:50.183

The result is in reverse order :( – RSFalcon7 – 2014-04-01T22:28:52.053

Perfect. @RSFalcon7 To un-reverse order just change it to sort{h($a)&lt;=&gt;h($b)} or make it reverse sort{.. – laggingreflex – 2015-01-03T03:21:33.073

50

There is an immensely useful tool I use called ncdu that is designed for finding those pesky high disk-usage folders and files, and removing them. It's console based, fast and light, and has packages on all the major distributions.

neutral

Posted 2009-02-25T13:42:42.613

Reputation:

8gt5 is in the same vein; its killer feature is displaying growth. – Tobu – 2010-07-01T16:16:35.787

Very nice... I wondier if the results could be fed to standard out... I am so lazy that I cannot read the manual – ojblass – 2009-06-27T05:17:09.737

1That's really cool! And much faster than hanging around with du, if you just want to identify the large directories. – BurninLeo – 2015-09-16T17:49:50.110

43

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

chrisharris.

Posted 2009-02-25T13:42:42.613

Reputation:

1@Mauro -- just pipe the result to head by adding | head -50 at the end. – Samuel Lelièvre – 2018-02-21T10:32:15.713

just what I was looking for thanks – Edward Tanguay – 2009-06-06T09:39:53.590

Can't use with du -k --total, gives error at the end du: cannot access 'total': No such file or directory – laggingreflex – 2015-01-03T02:51:36.983

i like this one more any other answer. how would you go to show only the first 50 results? – Mauro – 2016-01-12T04:25:24.937

20

As far as I can see you have three options:

  1. Alter du to sort before display.
  2. Alter sort to support human sizes for numerical sort.
  3. Post process the output from sort to change the basic output to human readable.

You could also do du -k and live with sizes in KiB.

For option 3 you could use the following 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

Douglas Leeder

Posted 2009-02-25T13:42:42.613

Reputation: 2 381

19

I've had that problem as well and I'm currently using a workaround:

du -scBM | sort -n

This will not produce scaled values, but always produce the size in megabytes. That's less then perfect, but for me it's better than nothing (or displaying the size in bytes).

Joachim Sauer

Posted 2009-02-25T13:42:42.613

Reputation: 721

I like th -BM switch, which is basically the same as -m, but it has the advantage of displaying the size and M postfixed to it, so you get 10M which is much clearer than just 10 :) – Tom Feiner – 2009-02-25T14:02:34.500

This is the simplest solution I've seen so far on this page, thank you! – Jeff Olson – 2015-11-05T16:35:05.367

18

Found this posting elsewhere. Therefore, this shell script will do what you want without calling du on everything twice. It uses awk to convert the raw bytes to a human-readable format. Of course, the formatting is slightly different (everything is printed to one decimal place precision).

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

Running this in my .vim directory yields:

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

(I hope 3.6M of color schemes isn't excessive.)

Adam Bellaire

Posted 2009-02-25T13:42:42.613

Reputation: 905

Both versions fail when filenames contain spaces – Vi. – 2010-11-02T17:54:13.080

1I have a Perl answer, too, but I think it might make people hate me: du -B1 | sort -nr | perl -e '%h=(0=>b,1=>K,2=>M,3=>G);for(<>){($s,@f)=split/\s+/;$e=3;$e-- while(1024$e>$s);$v=($s/(1024$e));printf "%-8s%s\n",sprintf($v >= 100 ? "%d%s" : "%.1f%s",$s/(1024**$e),$h{$e}),@f;}' – Adam Bellaire – 2009-02-25T14:40:17.623

Even though the Perl answer actually gives its formatting much closer to du. Although the rounding is off... It looks like du always gives ceil() rather than round() – Adam Bellaire – 2009-02-25T14:41:38.710

Hey, why did I use a hash there? Should've been an array... morning-brain grumble.... – Adam Bellaire – 2009-02-25T15:33:23.470

Added a better Perl solution as another answer. – Adam Bellaire – 2009-02-25T21:06:35.960

14

This version uses awk to create extra columns for sort keys. It only calls du once. The output should look exactly like du.

I've split it into multiple lines, but it can be recombined into a one-liner.

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

Explanation:

  • BEGIN - create a string to index to substitute 1, 2, 3 for K, M, G for grouping by units, if there's no unit (the size is less than 1K), then there's no match and a zero is returned (perfect!)
  • print the new fields - unit, value (to make the alpha-sort work properly it's zero-padded, fixed-length) and original line
  • index the last character of the size field
  • pull out the numeric portion of the size
  • sort the results, discard the extra columns

Try it without the cut command to see what it's doing.

Here's a version which does the sorting within the AWK script and doesn't need 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]]}'

Dennis Williamson

Posted 2009-02-25T13:42:42.613

Reputation: 49 345

Great thanks for that. I changed the du to du -sh * to show just the immediate files and directories without recursive descent. – HankCa – 2016-12-09T22:01:20.753

thank you! this is the first example that works for me in OS X 10.6 not counting the perl/phython-scripts. and thanks again for the good explanation. always nice to learn something new. awk sure is a powerful tool. – Wolf – 2011-05-04T12:09:42.557

13

Here's an example that shows the directories in a more compact summarized form. It handles spaces in directory/filenames.

% 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

slm

Posted 2009-02-25T13:42:42.613

Reputation: 4 819

1macOS/OSX users be warned that the mac version of xargs doesn’t support the -d flag, and if you omit it, any directories that contain a space have each word parsed separately which of course fails. – jasonology – 2017-07-19T04:40:49.910

9

sort files by size in MB

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

lukmansh

Posted 2009-02-25T13:42:42.613

Reputation: 1

8

I've a simple but useful python wrapper for du called dutop. Note that we (the coreutils maintainers) are considering adding the functionality to sort to sort "human" output directly.

pixelbeat

Posted 2009-02-25T13:42:42.613

Reputation: 216

And as ptman mentions below: ta da! (new sort flag)

– Tobu – 2010-07-01T16:13:23.903

1+1 for one of the rare, valid exceptions to "do one thing and do it right". Unless someone gets sort to understand the SI-prefix and/or the binary prefixes. – Joachim Sauer – 2009-03-18T22:20:39.717

8

Got another one:

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

I'm starting to like perl. You might have to do a

$ cpan Number::Bytes::Human

first. To all the perl hackers out there: Yes, I know that the sort part can also be done in perl. Probably the du part, too.

0x89

Posted 2009-02-25T13:42:42.613

Reputation: 2 700

6

Use the "-g" flag

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

And on my /usr/local directory produces output like this:

$ 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

Mick T

Posted 2009-02-25T13:42:42.613

Reputation: 129

4That doesn't give the human-readable output, though, which is what the OP was looking for. – None – 2009-02-25T17:24:57.180

6

This snippet was shameless snagged from 'Jean-Pierre' from http://www.unix.com/shell-programming-scripting/32555-du-h-sort.html. Is there a way I can better credit him?

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

Bozojoe

Posted 2009-02-25T13:42:42.613

Reputation: 324

i think if it is a very big number, then the unit is gone and the number displayed is small... try 23423423432423 – 太極者無極而生 – 2015-04-22T09:18:47.923

4

Another one:

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

Dimitre Radoulov

Posted 2009-02-25T13:42:42.613

Reputation: 111

3

Found this one on line... seems to work OK

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

Peter NUnn

Posted 2009-02-25T13:42:42.613

Reputation: 290

Loosely based on this one-liner, I created a script for providing a human-readable, sorted du(1) output. Please refer to my answer, https://serverfault.com/a/937459/218692.

– Tripp Kinetics – 2018-10-26T22:10:11.880

2

I learned awk from concocting this example yesterday. It took some time, but it was great fun, and I learned how to use awk.

It runs only du once, and it has a output much similar to 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 }'

It shows numbers below 10 with one decimal point.

marlar

Posted 2009-02-25T13:42:42.613

Reputation: 381

2

Here is the simple method I use, very low resource usage and gets you what you need:

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

JacobN

Posted 2009-02-25T13:42:42.613

Reputation: 151

2

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

Patrick

Posted 2009-02-25T13:42:42.613

Reputation: 41

1

Voilà:

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

weeheavy

Posted 2009-02-25T13:42:42.613

Reputation: 3 664

1

http://dev.yorhel.nl/ncdu

command: ncdu

Directory navigation, sorting (name and size), graphing, human readable, etc...

Adam Eickhoff

Posted 2009-02-25T13:42:42.613

Reputation: 1

1Great utility, but not installed by default on any OS I'm aware of. Not necessarily a problem, but one more program to have to look after... – voretaq7 – 2011-11-29T23:07:31.360

1

Another awk solution -

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

user96753

Posted 2009-02-25T13:42:42.613

Reputation:

1

I had been using the solution provided by @ptman, but a recent server change made it no longer viable. Instead, I'm using the following bash script:

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

Keith Yoder

Posted 2009-02-25T13:42:42.613

Reputation: 11

The BSD du -d 1 syntax has been supported by GNU du since coreutils 8.6 was released in 2010 (though its first Red Hat availability was RHEL 7 in 2014), so you no longer need --maxdepth=1. I only found out about this recently myself.

– Adam Katz – 2017-05-03T21:47:29.470

1

If you need to handle spaces you can use the following

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

The additional sed statement will help alleviate issues with folders with names such as Application Support

Chealion

Posted 2009-02-25T13:42:42.613

Reputation: 5 520

Just tried this on macOS Sierra. Works as expected. Nice! – jasonology – 2017-07-19T04:44:57.390

1

There are a lot of answers here, many of which are duplicates. I see three trends: piping through a second du call, using complicated shell/awk code, and using other languages.

Here is a POSIX-compliant solution using du and awk that should work on every system.

I've taken a slightly different approach, adding -x to ensure we stay on the same filesystem (I only ever need this operation when I'm short on disk space, so why weed out stuff I've mounted within this FS tree or moved and symlinked back?) and displaying constant units to make for easier visual parsing. In this case, I typically choose not to sort so I can better see the hierarchical structure.

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

(Since this is in consistent units, you can then append | sort -n if you really want sorted results.)

This filters out any directory whose (cumulative) content fails to exceed 512MB and then displays sizes in gigabytes. By default, du uses a 512-byte block size (so awk's condition of 220 blocks is 512MB and its 221 divisor converts the units to GB — we could use du -kx with $1 > 512*1024 and s/1024^2 to be more human-readable). Inside the awk condition, we set s to the size so we can remove it from the line ($0). This retains the delimiter (which is collapsed to a single space), so the final %s represents a space and then the aggregated directory's name. %7s aligns the rounded %.2f GB size (increase to %8s if you have >10TB).

Unlike most of the solutions here, this properly supports directories with spaces in their names (though every solution, including this one, will mishandle directory names containing line breaks).

Adam Katz

Posted 2009-02-25T13:42:42.613

Reputation: 512

0

Here's my solution, a simple bash script that only calls du once, and shows you only directories of size 1 MB or larger:

#!/bin/env bash
# Usage: my_du.sh [subdirectory levels]
#   For efficiency, only calls "du" once, and stores results in a temp file
#   Stephen Becker, 2/23/2010

if [ $# -gt 0 ]; then
# You may prefer, as I do, to just summarize the contents of a directory
# and not view the size of its subdirectories, so use this:
    du -h --max-depth $1 > temp_du_file
else
    du -h > temp_du_file
fi


# Show all directories of size > 1 GB:
cat temp_du_file | grep "^\([0-9]\|\.\)\+G" | sort -nr
# Show all directories of size > 1 MB:
cat temp_du_file | grep "^\([0-9]\|\.\)\+M" | sort -nr

rm temp_du_file

Stephen

Posted 2009-02-25T13:42:42.613

Reputation:

0

Why not throw another hat into the ring.... it's an old question, but here's an example that is (mostly) pure shell script (fwiw) -- i.e, just bash and no perl/python/awk/etc. So in that sense maybe it offers something new to the discussion (or not). It calculates file size just once, but prints in various units (my preference). (The un-simplified version includes getopts that excludes "GB" if unwanted.)

#!/bin/bash

printf -- ' %9s %9s %9s       %-30s\n' 'K'        'M'        'G'        'Path'
printf -- ' %9s %9s %9s       %-30s\n' '--------' '--------' '--------' '-----------'
du -sk "$@" | while read val; do
    file=$(echo "$val" | cut -f2-)
    size_k=$(echo "$val"  | cut -f1)
    printf ' %9s %9s %9s       %-30s\n' \
          ${size_k}  \
          $(( size_k / 1024 ))  \
          $(( size_k / 1024 / 1024 ))  \
          "$file"
  done | sort -n

michael

Posted 2009-02-25T13:42:42.613

Reputation: 354

0

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

ageek2remember

Posted 2009-02-25T13:42:42.613

Reputation: 101

That's not a great solution, because it traverses the file system twice. – Paul Gear – 2015-09-30T00:06:16.867

0

At least with the usual tools, this will be hard because of the format the human-readable numbers are in (note that sort does a "good job" here as it sorts the numbers - 508, 64, 61, 2, 2 - it just can't sort floating point numbers with an additional multiplier).

I'd try it the other way round - use the output from "du | sort -n -r" and afterwards convert the numbers to human-readable format with some script or program.

schnaader

Posted 2009-02-25T13:42:42.613

Reputation: 121

0

What you can try is:

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

Hope that helps.

Christian Witts

Posted 2009-02-25T13:42:42.613

Reputation:

that's what xargs does ;-) – cadrian – 2009-02-25T14:05:51.840

hehe, I always forget about xargs. ;) At the end of the day, whatever gets the job done imo. – None – 2009-02-25T15:05:20.480

MacOSX by default (i.e. outside of home-brew) doesn't support a proper xargs so this form was necessary. However for files with spaces in them you need to set IFS: IFS=$'\n' – HankCa – 2016-01-30T11:16:05.307

0

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

Nathan de Vries

Posted 2009-02-25T13:42:42.613

Reputation:

0

The following solution is similar to cadrian's original however this will only run 2 du commands as opposed to one du for each directory in the tree.

du -hs `du |sort -g |cut -f2- `

However Cardrian's solution is more robust as the above will not work for very heavily populated trees as it could exceed the limit on the size of the arguments passed to du

Steve Weet

Posted 2009-02-25T13:42:42.613

Reputation: 109

0

This is the alias I have in my .profile

alias du='sudo du -xh --max-depth=1 | sort -h'

sort -h is what really helps here to the question asked.

Another useful options are du -x to stay on the same filesystem; also sudo helps not to see errors if there are directories that aren't world-readable. Also, I always do du --max-depth=1, then drill down further etc..

Tagar

Posted 2009-02-25T13:42:42.613

Reputation: 131

0

Sorts in descending order.

du -s ./* | sort -n| cut -f 2-| xargs du -sh {}

Peter Nduati

Posted 2009-02-25T13:42:42.613

Reputation: 172

0

Here is an example

du -h /folder/subfolder --max-depth=1 | sort -hr

Returns:

233M    /folder/subfolder
190M    /folder/subfolder/myfolder1
15M     /folder/subfolder/myfolder4
6.4M    /folder/subfolder/myfolder5
4.2M    /folder/subfolder/myfolder3
3.8M    /folder/subfolder/myfolder2

You could also add | head -10 to find the top 10 or any number of sub-folders in the specified directory.

ode2k

Posted 2009-02-25T13:42:42.613

Reputation: 152

0

Loosely based on the logic in this one-liner, I wrote a script that provides a sorted human-readable du(1) output. Other than requiring the -h flag for human-readability, it requires no other non-POSIX-compatible commands.

It is available at https://github.com/pleappleappleap/sorted-human-du.

Tripp Kinetics

Posted 2009-02-25T13:42:42.613

Reputation: 112

-1

Instead of raping du and friends, you can use ls alone to do what you want:

ls -1Ssh

That will print all files sorted by size written in human-readable form. The first line it prints is the total, if you want to get rid of it you can simply use

ls -1Ssh | tail -n +2

You can add the -r flag to ls if you want the files in the reversed order (from smallest to largest).

drrlvn

Posted 2009-02-25T13:42:42.613

Reputation: 129

At least here, that doesn't work.

houdini@clanspum:~/ &gt; ls -1Ssh | grep clanspum 4.0K drwxr-xr-x 27 houdini users 4.0K 2010-02-15 12:35 clanspum/ 0 drwxr-xr-x 2 houdini users 77 2010-02-15 13:06 clanspum-s/ houdini@clanspum:~/ &gt; du -sh clanspum/ 602M clanspum/ – Bill Weiss – 2010-02-23T20:40:24.790

3... pretend that was formatted correctly. Point is, it shows a directory as being "4.0K", while du -sh shows "602M". The latter is correct. – Bill Weiss – 2010-02-23T20:40:58.377