lanqy/bytesToSize.js

pe77 · 2015-11-24T19:25:44Z

Nice

williamoliveira · 2017-01-23T00:56:55Z

ES6 and airbnb's eslint compliant version:

function bytesToSize(bytes) {
  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB']
  if (bytes === 0) return 'n/a'
  const i = parseInt(Math.floor(Math.log(bytes) / Math.log(1024)), 10)
  if (i === 0) return `${bytes} ${sizes[i]})`
  return `${(bytes / (1024 ** i)).toFixed(1)} ${sizes[i]}`
}

Oluwasetemi · 2017-03-12T09:26:42Z

function bytesToSize(bytes) {
const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB']
if (bytes === 0) return 'n/a'
const i = parseInt(Math.floor(Math.log(bytes) / Math.log(1024)), 10)
if (i === 0) return ${bytes} ${sizes[i]})
return ${(bytes / (1024 ** i)).toFixed(1)} ${sizes[i]}
}

deathwebo · 2018-07-30T23:41:54Z

With little typo fixed on line 5:

function bytesToSize(bytes) {
  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB']
  if (bytes === 0) return 'n/a'
  const i = parseInt(Math.floor(Math.log(bytes) / Math.log(1024)), 10)
  if (i === 0) return `${bytes} ${sizes[i]}`
  return `${(bytes / (1024 ** i)).toFixed(1)} ${sizes[i]}`
}

seahindeniz · 2018-12-24T04:47:21Z

Some may doesn't like having a seperator so:

function bytesToSize(bytes, seperator = "") {
  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB']
  if (bytes == 0) return 'n/a'
  const i = parseInt(Math.floor(Math.log(bytes) / Math.log(1024)), 10)
  if (i === 0) return `${bytes}${seperator}${sizes[i]}`
  return `${(bytes / (1024 ** i)).toFixed(1)}${seperator}${sizes[i]}`
}

console.log( bytesToSize(2659633) ); // 2.5MB
console.log( bytesToSize(2659633, " ") ); // 2.5 MB
console.log( bytesToSize(2659633, "-") ); // 2.5-MB

jedfoster · 2019-01-03T20:45:07Z

I had a need to format negative values, but Math.log(x) returns NaN if x is negative, so I pass bytes through Math.abs() first.

function bytesToSize(bytes) {
  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
  if (bytes === 0) return 'n/a';
  const i = parseInt(Math.floor(Math.log(Math.abs(bytes)) / Math.log(1024)), 10);
  if (i === 0) return `${bytes} ${sizes[i]}`;
  return `${(bytes / (1024 ** i)).toFixed(1)} ${sizes[i]}`;
}

console.log(bytesToSize(1234567)); // 1.2 MB
console.log(bytesToSize(-1234567)); // -1.2 MB

jzombie · 2019-10-17T01:19:26Z

@jedfoster I used your code, but just pointing out something... If you're only rendering "Bytes", there's a dangling closing parenthesis.

e.g. "Bytes)"

StasAreshin · 2020-01-13T10:49:39Z

1 redundant line removed
added suffix param
fixed error if size more then 1023 TB

function prettySize(bytes, separator = '', postFix = '') {
    if (bytes) {
        const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
        const i = Math.min(parseInt(Math.floor(Math.log(bytes) / Math.log(1024)), 10), sizes.length - 1);
        return `${(bytes / (1024 ** i)).toFixed(i ? 1 : 0)}${separator}${sizes[i]}${postFix}`;
    }
    return 'n/a';
}

Akifcan · 2020-02-03T14:10:25Z

thank you

ZachMoreno · 2020-04-04T21:40:56Z

fixed a type error on line 4, Argument of type 'number' is not assignable to parameter of type 'string'

prettySize(bytes, separator = '', postFix = '') {
    if (bytes) {
        const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
        const i = Math.min(parseInt(Math.floor(Math.log(bytes) / Math.log(1024)).toString(), 10), sizes.length - 1);
        return `${(bytes / (1024 ** i)).toFixed(i ? 1 : 0)}${separator}${sizes[i]}${postFix}`;
    }
    return 'n/a';
}

zackster · 2020-04-14T02:13:09Z

A little bit of code for people who want the reverse.
Basically adapted this from https://stackoverflow.com/a/31625253/104461

function printpower (n, base, power) {
  if (base === 2) { // 1 << power is approx 10x faster than Math.pow(2, power) 
    console.log(n * (1 << power))
  } else {
    console.log(n * Math.pow(base, power))
  }
}

const humanReadable = '86 MB'

const [n, abbreviation] = humanReadable.split(/\s+/)
if (abbreviation) {
  if (/K(iB)?$/.test(abbreviation)) {
    printpower(n, 2, 10)
  } else if (/M(iB)?$/.test(abbreviation)) {
    printpower(n, 2, 20)
  } else if (/G(iB)?$/.test(abbreviation)) {
    printpower(n, 2, 30)
  } else if (/T(iB)?$/.test(abbreviation)) {
    printpower(n, 2, 40)
  } else if (/KB$/.test(abbreviation)) {
    printpower(n, 10, 3)
  } else if (/MB$/.test(abbreviation)) {
    printpower(n, 10, 6)
  } else if (/GB$/.test(abbreviation)) {
    printpower(n, 10, 9)
  } else if (/TB$/.test(abbreviation)) {
    printpower(n, 10, 12)
  }
} else {
  console.log(n)
}

Edit: the if statement is probably pretty expensive, and so are the Regular Expressions (at a minimum, should be compiled once as const variables), so there is room for incremental optimization!

tobiasalbirosa · 2020-11-17T21:11:57Z

Thanks all of you

ahmnouira · 2021-01-12T07:27:35Z

TypeScript version:

export function bytesToSize(bytes: number): string {
  const sizes: string[] = ['Bytes', 'KB', 'MB', 'GB', 'TB']
  if (bytes === 0) return 'n/a'
  const i: number = parseInt(Math.floor(Math.log(bytes) / Math.log(1024)).toString())
  if (i === 0) return `${bytes} ${sizes[i]}`
  return `${(bytes / Math.pow(1024, i)).toFixed(1)} ${sizes[i]}`
}

trankov · 2021-07-14T19:10:04Z

Strength and power of open source community. I'm shocked and impressed. Thanks to all, guys.

denik1981 · 2021-08-27T18:34:54Z

function bytesToSize(bytes) {
  const units = ["byte", "kilobyte", "megabyte", "terabyte", "petabyte"];
  const unit = Math.floor(Math.log(bytes) / Math.log(1024));
  return new Intl.NumberFormat("en", {style: "unit", unit: units[unit]}).format(bytes / 1024 ** unit);
}

rmorlok · 2022-07-08T17:29:06Z

To expand on the typescript version, I don't think the parseInt(...) is required. Also, in the unlikely case that you exceed 999.9 TB, you end up in xxx.x undefined territory.

Here is a fixed Typescript version:

export function bytesToSize(bytes: number): string {
  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
  if (bytes === 0) return 'n/a';
  const i = Math.min(Math.floor(Math.log(bytes) / Math.log(1024)), sizes.length - 1);
  if (i === 0) return `${bytes} ${sizes[i]}`;
  return `${(bytes / (1024 ** i)).toFixed(1)} ${sizes[i]}`;
}

With Jest spec:

describe('bytesToSize', () => {
  test.each([
    [0, 'n/a'],
    [1, '1 Bytes'],
    [2000, '2.0 KB'],
    [30000, '29.3 KB'],
    [400000, '390.6 KB'],
    [5000000, '4.8 MB'],
    [60000000, '57.2 MB'],
    [700000000, '667.6 MB'],
    [8000000000, '7.5 GB'],
    [90000000000, '83.8 GB'],
    [100000000000, '93.1 GB'],
    [1100000000000, '1.0 TB'],
    [12000000000000, '10.9 TB'],
    [130000000000000, '118.2 TB'],
    [1400000000000000, '1273.3 TB'],
    [15000000000000000, '13642.4 TB'],
  ])('.bytesToSize(%p)', (
    val: number,
    expected: string,
  ) => {
    expect(
      bytesToSize(val),
    ).toBe(expected);
  });
});

Dymerz · 2022-11-23T18:35:08Z

Using the Intl.NumberFormat for local friendly conversions

export function bytesToSize(bytes: number): string {
  const units = ['byte', 'kilobyte', 'megabyte', 'gigabyte', 'terabyte'];

  const navigatorLocal = navigator.languages && navigator.languages.length >= 0 ? navigator.languages[0] : 'en-US'
  const unitIndex      = Math.max(0, Math.min(Math.floor(Math.log(bytes) / Math.log(1024)), units.length - 1));

  return Intl.NumberFormat(navigatorLocal, {
    style: 'unit',
    unit : units[unitIndex]
  }).format(bytes / (1024 ** unitIndex))
}

HaukeHa · 2023-09-28T06:57:36Z

The sizes should be named Mebibyte (MiB), Gibibyte (GiB) etc if you use 1024 for the calculation.

Or if you want to calculate Megabyte, Gigabyte etc. replace the '1024' in the code by '1000'.

gynekolog · 2023-11-09T14:11:52Z

@HaukeHa Thank you for noticing 👍

I use the following code:

export function convertBytes(bytes: number, options: { useBinaryUnits?: boolean; decimals?: number } = {}): string {
  const { useBinaryUnits = false, decimals = 2 } = options;

  if (decimals < 0) {
    throw new Error(`Invalid decimals ${decimals}`);
  }

  const base = useBinaryUnits ? 1024 : 1000;
  const units = useBinaryUnits
    ? ["Bytes", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB"]
    : ["Bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];

  const i = Math.floor(Math.log(bytes) / Math.log(base));

  return `${(bytes / Math.pow(base, i)).toFixed(decimals)} ${units[i]}`;
}

and basic tests:

import { describe, expect } from "vitest";
import { convertBytes } from "./bytes";

describe("convertBytes", () => {
  const fileSizeInBytes = 2048;

  describe("default conversion", () => {
    it("should convert to KB", () => {
      const resultKB = convertBytes(fileSizeInBytes);
      expect(resultKB).toBe("2.05 KB");
    });

    it("should convert to MB", () => {
      const resultMB = convertBytes(fileSizeInBytes * 1000);
      expect(resultMB).toBe("2.05 MB");
    });

    it("should throw an error for invalid decimals", () => {
      expect(() => convertBytes(fileSizeInBytes, { decimals: -1 })).toThrowError("Invalid decimals -1");
    });
  });

  describe("conversion to binary units", () => {
    it("should convert to KiB", () => {
      const resultKiB = convertBytes(fileSizeInBytes, { useBinaryUnits: true });
      expect(resultKiB).toBe("2.00 KiB");
    });

    it("should convert to MiB", () => {
      const resultMiB = convertBytes(fileSizeInBytes * 1024, { useBinaryUnits: true });
      expect(resultMiB).toBe("2.00 MiB");
    });
  });

  it("should handle very large bytes (Number.MAX_SAFE_INTEGER)", () => {
    const result = convertBytes(Number.MAX_SAFE_INTEGER);
    expect(result).toBe("9.01 PB");
  });
});

artembelik · 2024-03-18T11:18:06Z

  const units = ["byte", "kilobyte", "megabyte", "terabyte", "petabyte"];

you lost "gigabyte"

weroro-sk · 2025-01-30T17:34:44Z

@gynekolog I implemented a simple word declension for the word "byte".

export const convertBytes = (bytes: number, options: { useBinaryUnits?: boolean; decimals?: number } = {}): string => {
    const {useBinaryUnits = false, decimals = 2} = options;

    if (decimals < 0)
        throw new Error(`Invalid decimals ${decimals}`);

    const declension = <T extends unknown>(num: number, dictionary: T[]): T =>
        (num = Math.abs(num)) === 1
            ? dictionary[1]
            : (num > 1 && num < 5)
                ? dictionary[2]
                : dictionary[0];

    const base = useBinaryUnits ? 1024 : 1000;
    const i = Math.floor(Math.log(Math.abs(bytes)) / Math.log(base));
    const value = bytes / Math.pow(base, i);
    const units = useBinaryUnits
        ? [["Bytes", "Byte", "Bytes"], "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB"]
        : [["Bytes", "Byte", "Bytes"], "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];

    let unit = units[i];

    return `${value.toFixed(decimals)} ${Array.isArray(unit) ? declension(value, unit) : unit}`;
}

Example:

convertBytes(0); // 0 Bytes
convertBytes(1); // 1 Byte
convertBytes(2); // 2 Bytes
convertBytes(3); // 3 Bytes
convertBytes(6); // 6 Bytes
convertBytes(987); // 987 Bytes
convertBytes(34523465); // 34.52 MB

I'm from Slovakia, so in my case it would be:

const units = useBinaryUnits
    ? [["Bajtov", "Bajt", "Bajty"], "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB"]
    : [["Bajtov", "Bajt", "Bajty"], "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];

convertBytes(0); // 0 Bajtov
convertBytes(1); // 1 Bajt
convertBytes(2); // 2 Bajty
convertBytes(3); // 3 Bajty
convertBytes(4); // 4 Bajty
convertBytes(5); // 5 Bajtov
convertBytes(6); // 6 Bajtov
convertBytes(987); // 987 Bajtov
convertBytes(34523465); // 34.52 MB

gynekolog · 2025-01-31T15:12:02Z

@weroro-sk Good point, thanks for sharing! I gave it a try my way just for fun. The code uses Intl.PluralRules, but the whole function is more robust now. Feel free to check it out.

brianmontanaocient · 2025-03-11T16:17:59Z

Shouldn't 999999999 return 1 GB and not 1000 MB, since 1000000000 returns 1 GB.

flycran · 2026-03-15T08:40:05Z

If you find yourself tweaking this snippet frequently, smart-unit might be worth a look — it handles this out of the box with configurable decimal places, TypeScript support, and bidirectional format/parse:

const size = new SmartUnit(['B', 'KB', 'MB', 'GB', 'TB'], { baseDigit: 1024 });
size.format(1234);    // "1.21KB"
size.parse('1.5GB'); // 1610612736

And bytes formatting is just one use case — the same API works for any unit system with variable ratios, like time, length, frequency, or anything custom:

const time = new SmartUnit(['ms', 1000, 's', 60, 'm', 60, 'h']);
time.format(5400000); // "1.5h"

	// from http://scratch99.com/web-development/javascript/convert-bytes-to-mb-kb/
	function bytesToSize(bytes) {
	var sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
	if (bytes == 0) return 'n/a';
	var i = parseInt(Math.floor(Math.log(bytes) / Math.log(1024)));
	if (i == 0) return bytes + ' ' + sizes[i];
	return (bytes / Math.pow(1024, i)).toFixed(1) + ' ' + sizes[i];
	};

lanqy/bytesToSize.js

pe77 commented Nov 24, 2015

Uh oh!

williamoliveira commented Jan 23, 2017

Uh oh!

Oluwasetemi commented Mar 12, 2017

Uh oh!

deathwebo commented Jul 30, 2018

Uh oh!

seahindeniz commented Dec 24, 2018 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

jedfoster commented Jan 3, 2019 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

jzombie commented Oct 17, 2019

Uh oh!

StasAreshin commented Jan 13, 2020 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Akifcan commented Feb 3, 2020

Uh oh!

ZachMoreno commented Apr 4, 2020

Uh oh!

zackster commented Apr 14, 2020 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

tobiasalbirosa commented Nov 17, 2020

Uh oh!

ahmnouira commented Jan 12, 2021

Uh oh!

trankov commented Jul 14, 2021

Uh oh!

denik1981 commented Aug 27, 2021 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

rmorlok commented Jul 8, 2022

Uh oh!

Dymerz commented Nov 23, 2022

Uh oh!

HaukeHa commented Sep 28, 2023

Uh oh!

gynekolog commented Nov 9, 2023 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

artembelik commented Mar 18, 2024

Uh oh!

weroro-sk commented Jan 30, 2025

Uh oh!

gynekolog commented Jan 31, 2025

Uh oh!

brianmontanaocient commented Mar 11, 2025

Uh oh!

flycran commented Mar 15, 2026

Uh oh!

seahindeniz commented Dec 24, 2018 •

edited

Loading

jedfoster commented Jan 3, 2019 •

edited

Loading

StasAreshin commented Jan 13, 2020 •

edited

Loading

zackster commented Apr 14, 2020 •

edited

Loading

denik1981 commented Aug 27, 2021 •

edited

Loading

gynekolog commented Nov 9, 2023 •

edited

Loading