Dealing with KB, MB, GB and TB and bytes

Question

This function is simple, it gets a number of bytes and returns its representation in either Bytes, KB, MB, GB and TB.

As simple as it is, I am sure there are other (and perhaps better ways) to write it.

function kmgtbytes (num) {
    if (num > 0 ){
        if (num < 1024)             { return [num, "Bytes"] }
        if (num < 1048576)          { return [num/1024, "KB"] }
        if (num < 1073741824)       { return [num/1024/1024, "MB"] }
        if (num < 1099511600000)    { return [num/1024/1024/1024, "GB"] }

        return [num/1024/1024/1024/1024, "TB"]
    }

    return num
}

Answer 1

Here's a slightly less repetitive way to write it since we know each unit is 1024 as large as the last:

function kmgtbytes (num) {
    var unit, units = ["TB", "GB", "MB", "KB", "Bytes"];
    for (unit = units.pop(); units.length && num >= 1024; unit = units.pop()) {
        num /= 1024;
    }
    return [num, unit];
}

Answer 2

What about:

var units=["Byte","KB","MB","GB","TB","PB"];

function getUnit(bytes){
    for(var i of units){
        if(bytes<1024) return bytes+" "+units[i];
        bytes/=1024;
    }
}

Edit:

It prevents you from precalculating your values for each if-clause. It's easily extensible: Just add another unit, wherever you want. And for the rest: it does its job in an easy understandable way. No rocket science.

Answer 3

You can use logarithms:

var sizes = ["bytes", "KB", "MB", "GB", "TB"];

function formatSize(bytes) {
    var l = Math.min(sizes.length - 1, Math.log(bytes) / Math.LN2 / 10 | 0);
    return [bytes / Math.pow(1024, l), sizes[l]];
}

The confusing part, Math.log(bytes) / Math.LN2 / 10 | 0, gets the base-1024 logarithm of bytes and truncates it.

Answer 4

I will discuss 2 points to your code: Readability/Cleanliness and Robustness

From the Readability/Cleanliness perspective I'd argue that your code is the easiest to read vs any answer you've received thus far. I knew in 3 seconds the purpose of all of that code and wouldn't need any comments to further explain it.

From the robustness perspective it all boils down to the use case of the code. If you know without a doubt that you will only ever see positive sized numbers <1024 TB I'd say again your code is fine. If you wanted to handle file size differences (as in 100kb-150kb = -50kb) or file sizes beyond 1023TB then clearly you need to enhance your approach.

To handle the more general case this question has already been answered here as well: https://stackoverflow.com/questions/281640/how-do-i-get-a-human-readable-file-size-in-bytes-abbreviation-using-net/4975942#4975942

As a side note it would appear size=0 would return [0,] but size of 1 would return [1,Bytes]. You may want to return [0,Bytes]

Answer 5

How about recursion? (http://jsfiddle.net/WhhCL/1/)

var units = ["Bytes", "KB", "MB", "GB", "TB"];

function unitize(num) {
    return unitizer(num, 0);
}

function unitizer(num, level) {
    if (num < 1024 || level > units.length - 1) {
        return num + " " + units[level];
    } else {
        return unitizer(num / 1024, level + 1);
    }
}

The readability of your original function is tough to beat. At least for now, it's also the most performant of the bunch.

Answer 6

I'd use a while loop, divide by 1024 and keep track of how many times you divided.

This is my completely bonkers function:

function resolve_to_power_of(bytes, power) {
    var powers;
    powers = 0;
    while (bytes >= power) {
        powers += 1;
        bytes = bytes / power;
    }
    return {
        quantity: bytes,
        powers: powers
    };
}

function format_default(bytes) {
    var resolved, descriptors;
    resolved = resolve_to_power_of(bytes, 1024);
    descriptors = [ "B", "KB", "MB", "TB", "GB", "PB", "EB", "ZB", "YB" ];
    return Math.ceil(resolved.quantity) + " " + descriptors[resolved.powers];
}

format_default(1024); // 1 KB
format_default(1000); // 1000 B
format_default(102400); // 100 KB

The reason it's set up like this is because it also supports dividing by 1000 and other byte lables like [ "B", "K", "M" .. ] etc. following IEC and SI standards.

Answer 7

You can loop through the thousands until the number is small enough, then just return the remaining number and the corresponding unit:

function kmgtbytes(num) {
  for (var i = 0; num >= 1024 && i < 4; i++) num /= 1024;
  return [num, ["Bytes","kB","MB","GB","TB"][i]];
}