Javascript human readable byte size function

31 March, 2020

Here is a small function which converts a bytes in to a readable format (B, KB, MB, GB, TB).

Function

const TB = 1000000000000;
const GB = 1000000000;
const MB = 1000000;
const KB = 1000;

function bytesReadable(byteSize, decimals) {
    let unit;
    let i;
    let remainder;

    // Get the whole number, and the remainder for the
    // decimals later on.
    if (byteSize > TB) {
        unit = "TB";
        i = Math.floor(byteSize / TB);
        remainder = byteSize - (i * TB);
    }else if (byteSize > GB) {
        unit = "GB";
        i = Math.floor(byteSize / GB);
        remainder = byteSize - (i * GB);
    }else if (byteSize > MB) {
        unit = "MB";
        i = Math.floor(byteSize / MB);
        remainder = byteSize - (i * MB);

    }else if (byteSize > KB){
        unit = "KB";
        i = Math.floor(byteSize / KB),
            remainder = byteSize - i * KB;
    }else{
        // Can't go smaller than bytes!
        return i.toString() + " " + unit;
    }

    if (decimals === 0){
        return i.toString() + " " + unit;
    }

    // Now we calculate the eventual missing leading
    // zeroes to pad up if needed.
    let width;
    if (remainder > GB){
        width = 12;
    }else if (remainder > MB){
        width = 9;
    }else if (remainder > KB){
        width = 6;
    }else{
        width = 3;
    }

    // Fill up leading zeroes if they are missing
    let remainderString = remainder.toString();

    for (let i = remainderString.length; i < width; i++){
        remainderString = "0" + remainderString;
    }

    // Check to prevent unwanted behaviour
    if (decimals > remainderString.length){
        decimals = remainderString.length;
    }

    return i.toString() + "." + remainderString.substr(0, decimals) + " " + unit;
}

Sample

console.log(bytesReadable(425005, 2));
console.log(bytesReadable(8741208, 2));
console.log(bytesReadable(114448910, 2));
console.log(bytesReadable(557891, 2));
console.log(bytesReadable(114710, 2));
console.log(bytesReadable(8933578, 2));
console.log(bytesReadable(5849684981, 2));
console.log(bytesReadable(12033687, 2));
console.log(bytesReadable(742289, 2));
console.log(bytesReadable(678007439, 2));

// Output
425.00 KB
  8.74 MB
114.44 MB
557.89 KB
114.71 KB
  8.93 MB
  5.84 GB
 12.03 MB
742.28 KB
678.00 MB

 

 

Golang human readable byte sizes

31 March, 2020

Here is a function that prints out byte sizes, like the return from len() function, into human readable units.

Function and example

package main

import (
	"fmt"
	"strconv"
)

const (
	TB = 1000000000000
	GB = 1000000000
	MB = 1000000
	KB = 1000
)

func lenReadable(length int, decimals int) (out string) {
	var unit string
	var i int
	var remainder int

	// Get whole number, and the remainder for decimals
	if length > TB {
		unit = "TB"
		i = length / TB
		remainder = length - (i * TB)
	} else if length > GB {
		unit = "GB"
		i = length / GB
		remainder = length - (i * GB)
	} else if length > MB {
		unit = "MB"
		i = length / MB
		remainder = length - (i * MB)
	} else if length > KB {
		unit = "KB"
		i = length / KB
		remainder = length - (i * KB)
	} else {
		return strconv.Itoa(length) + " B"
	}

	if decimals == 0 {
		return strconv.Itoa(i) + " " + unit
	}

	// This is to calculate missing leading zeroes
	width := 0
	if remainder > GB {
		width = 12
	} else if remainder > MB {
		width = 9
	} else if remainder > KB {
		width = 6
	} else {
		width = 3
	}

	// Insert missing leading zeroes
	remainderString := strconv.Itoa(remainder)
	for iter := len(remainderString); iter < width; iter++ {
		remainderString = "0" + remainderString
	}
	if decimals > len(remainderString) {
		decimals = len(remainderString)
	}

	return fmt.Sprintf("%d.%s %s", i, remainderString[:decimals], unit)
}

func main() {
	test := []int{425005, 8741208, 114448910, 557891, 557,
		114710, 8933578, 5849684981, 12033687, 742289, 678007439}

	for _, v := range test {
		fmt.Println(v, "\t = ", lenReadable(v, 2))
	}
}

Output

425005          =  425.00 KB
8741208         =  8.74 MB
114448910       =  114.44 MB
557891          =  557.89 KB
557             =  557 B
114710          =  114.71 KB
8933578         =  8.93 MB
5849684981      =  5.84 GB
12033687        =  12.03 MB
742289          =  742.28 KB
678007439       =  678.00 MB

Golang serving resume able file downloads with net/http

30 March, 2020

Here is a fully commented example golang function on how to serve and transmit files to clients with the go net/http package. It supports the "Accept-Ranges" header, which allows for downloads to be paused or interrupted and resumed later on. This is very useful for clients who don't have stable connections to download larger files. However this function does not support Multipart downloads, if you wish to have that functionality check this function in the net/http source code for implementation.

This function is written with the following sources RFC 7233 section 3.1MDN Range Requests and Content Range.

Jetbrains Webstorm chrome live edit fix

29 March, 2020

I was encountering problems with Jetbrains not connecting to chrome IDE Support extension. For me the simple fix was setting the listener port of the extension to the correct value.

In chrome go the extension options page and set the port to.

63343

undefined

Now close chrome, go the IDE and hit that debug button, and behold the mighty message;

undefined

 

Home ← Older posts