Bsrgvty

I'm basically looking for files then sorting by the size. The script works if I don't sort the size by human readable. But I want the size to be human readable. How can I sort sizes that are human readable?

For example:

 ls -l | sort -k 5 -n | awk 'print $9 " " $5'

This works as expected, I got the size of my files in bytes ascending:

1.txt 1
test.txt 3
bash.sh* 573
DocGeneration.txt 1131
andres_stuff.txt 1465
Branches.xlsx 15087
foo 23735
bar 60566
2016_stuff.pdf 996850

Now, I want the size to be human readable, so I added an -h parameter to ls, and now some files are out of order:

 ls -lh | sort -k 5 -n | awk 'print $9 " " $5'

1.txt 1
DocGeneration.txt 1.2K
andres_stuff.txt 1.5K
test.txt 3
Branches.xlsx 15K
foo 24K
bar 60K
bash.sh* 573
2016_stuff.pdf 974K

Try sort -h k2

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

It is part of gnu sort, BSD sort, and others.

ls has this functionality built in, use the -S option and sort in reverse order: ls -lShr

 -r, --reverse
 reverse order while sorting

 -S sort by file size, largest first

Since no specific shell was mentioned, here's how to do the whole thing in the zsh shell:

ls -lhf **/*(.Lk-1024oL)

The ** glob pattern matches like * but across / in pathnames, i.e. like a recursive search would do.

The ls command would enable human readable sizes with -h, and long list output format with -l. The -f option disables sorting, so ls would just list the files in the order they are given.

This order is arranged by the **/*(.Lk-1024oL) filename globbing pattern so that the smaller files are listed first. The **/* bit matches every file and directory in this directory and below, but the (...) modifies the glob's behaviour (it's a "glob qualifier").

It's the oL at the end that orders (o) the names by file size (L, "length").

The . at the start makes the glob only match regular files (no directories).

The Lk-1024 bit selects files whose size is less than 1024 KB ("length in KB less than 1024").

If zsh is not your primary interactive shell, then you could use

zsh -c 'ls -lf **/*(.Lk-1024oL)'

Use setopt GLOB_DOTS (or zsh -o GLOB_DOTS -c ...)
to also match hidden names. ... or just add D to the glob qualifier string.

Expanding on the above, assuming that you'd want a 2-column output with pathnames and human readable sizes, and also assuming that you have numfmt from GNU coreutils,

zmodload -F zsh/stat b:zstat

for pathname in **/*(.Lk-1024oL); do
 printf '%st%sn' "$pathname" "$(zstat +size "$pathname" | numfmt --to=iec)"
done

or, quicker,

paste <( printf '%sn' **/*(.Lk-1024oL) ) 
 <( zstat -N +size **/*(.Lk-1024oL) | numfmt --to=iec )

If your sort does not have the -h option you could use an (albeit very long) awk command like the following:

find . -type f -size -1024k -exec ls -al ; | sort -k 5 -n | awk 'if ($5 > 1099511627776) print $9,$5/1024/1024/1024/1024"T" else if ($5 > 1073741824) print $9,$5/1024/1024/1024"G" else if ($5 > 1048576) print $9,$5/1024/1024"M" else if ($5 > 1024) print $9,$5/1024"K" else print $9,$5"B"' | column -t

This will sort your output in bytes and then convert them to their human readable size afterward.