#! perl -slw
use strict;

sub scaleIt {
    my( $size, $n ) =( shift, 0 );
    ++$n and $size /= 1024 until $size < 1024;
    return sprintf "%.2f %s", 
          $size, ( qw[ bytes KB MB GB ] )[ $n ];
}

my $size = -s $ARGV[ 0 ];

print "$ARGV[ 0 ]: ", scaleIt $size;
__END__
P:\test>for %f in (data\*) do @test1 %f
data\10GB.dat: 9.77 GB
data\10Mrand.dat: 85.83 MB
data\10Mrand.pp: 0.00 bytes
data\10Msort.p: 0.00 bytes
data\10Msort.pp: 0.00 bytes
data\1mb.dat: 1.06 MB
data\1Mx16384.dat: 15.26 GB
data\1Mx4096: 3.81 GB
data\50mb.dat: 52.93 MB
data\5mb.dat: 5.29 MB
...
[download]

my $kb = 1024 * 1024; # set to 1 Gb

my $mb = $kb >> 10;
my $gb = $mb >> 10;

print "$kb kb = $mb mb = $gb gb\n";
__END__
1048576 kb = 1024 mb = 1 gb
[download]

sub prettyBytes {
 my $size = $_[0];
 foreach ('b','kb','mb','gb','tb','pb')
 {
    return sprintf("%.2f",$size)."$_" if $size < 1024;
    $size /= 1024;
 }
}
[download]

Seems clear enough, why would you think it's ugly? Translating data to nice, user friendly strings can be very ugly, but this is quite minimal.
"What should it profit a man, if he should win a flame war, yet lose his cool?"

tell me i'm beautiful like you mean it.. :)

i actually wrote that after i posed the question. its better than what i first tried.

i'm still curious how other people would solve this, curiosity's sake!

Fix if size is larger than PB. <code> sub prettyBytes { my $size = $_[0]; foreach ('b','kb','mb','gb','tb','pb') { last if $size < 1024; $size /= 1024; } return sprintf("%.2f",$size)."$_"; } <code>

This does not work as expected as the value of $_ is undefined outside of the loop.

sub scaledbytes {
   (sort { length $a <=> length $b }
   map { sprintf '%.3g%s', $_[0]/1024**$_->[1], $_->[0] }
   [" bytes"=>0],[KB=>1],[MB=>2],[GB=>3],[TB=>4],[PB=>5],[EB=>6])[0]
}
[download]

Different :)

One interesting side effect of the sort is that zero length files get listed as 0KB rather than 0 bytes.

---

Examine what is said, not who speaks.

"Efficiency is intelligent laziness." -David Dunham
"Think for yourself!" - Abigail
"Memory, processor, disk in that order on the hardware side. Algorithm, algoritm, algorithm on the code side." - tachyon

# will need adjustment if you want to do negative values
# kbstring(1024) => 1KB
# MS uses a threshold of 0.98. I find this to be a perfectly
# acceptable threshold.  0.98*1024 == 1003.
sub kbstring {
  my $value = shift;
  my @prefix = ('', qw(K M G T));
  while (@prefix>1 && $value >= 1000) {
    shift @prefix;
    $value /= 1024;
  }
  return sprintf '%.2fdsB', $value, $prefix[0];
}
[download]

$"=$,,$_=q>|\p4<6 8p<M/_|<('=>
.q>.<4-KI<l|2$<6%s!<qn#F<>;$,
.=pack'N*',"@{[unpack'C*',$_]
}"for split/</;$_=$,,y[A-Z a-z]
         {}cd;print lc
[download]

I really wanted to handle quite large values, like some that are up into terabytes in just six months, and so I felt I needed to be able to handle large integers ala Math::BigInt. And I wanted to be able to handle the "K is 1000" vs. the "K is 1024" people. And I wanted to be able to reliably fit the output into a limited number of columns. Thus the following contortions...

edit...I mean divide by 1024

Divide by 1000? Are you selling disk drives? :-)

There is some debate about whether it's 1000 or 1024 but you should be consistent, whichever you choose. So if you have 1024B in a KB then you should have 1024KB in an MB and 1024 MB in a GB.

There is(was?) a proposal that since kilo and mega and giga already mean 10^3, 10^6 and 10^9 in all other fields that they should also mean that in computers and that we should say kibibyte, mebibyte and gigibyte (gibibyte?) when we're talking about the 1024 based versions. Needless to say this didn't catch on.

As for the original question, something like this would do the trick. I leave it as an excercise to fix the fact that 25 bytes comes out as 25.000B

my @sizes=qw( B KB MB GB TB PB);
sub nice_size
{
  my $size = shift;
  my $i = 0;

  while ($size > 1024)
  {
    $size = $size / 1024;
    $i++;
  }
  return sprintf("%.3f$sizes[$i]", $size);
}
[download]

There is some debate about whether it's 1000 or 1024

The SI units for these two multiples have been standardised. See, for instance: Prefixes for binary multiples. The 1000 multiple gets to keep the K, M, G prefixes (in line with existing physical units like metres and ohms that we are used to representing in terms of thousands).

For the 1024 multiple, the official term is binary: kilobinary, megabinary, yottabinary... abbreviated to KiB, MiB, GiB... YiB.

The real push for making the distinction didn't come from the disk drive world. The impetus came from the telecommunications field, where bitrates are commonly expressed in terms of thousand bits per second, not 1024. This is where the most confusion arose: telecom engineers talking to software developers didn't agree on what K meant.

- another intruder with the mooring of the heat of the Perl