pretty-bytes
Version:
Convert bytes to a human readable string: 1337 → 1.34 kB
253 lines (160 loc) • 6.98 kB
Markdown
# pretty-bytes
> Convert bytes to a human readable string: `1337` → `1.34 kB`
Useful for displaying file sizes for humans.
*Note that it uses base-10 (e.g. kilobyte).
[Read about the difference between kilobyte and kibibyte.](https://web.archive.org/web/20150324153922/https://pacoup.com/2009/05/26/kb-kb-kib-whats-up-with-that/)*
## Install
```sh
npm install pretty-bytes
```
## Usage
```js
import prettyBytes from 'pretty-bytes';
prettyBytes(1337);
//=> '1.34 kB'
prettyBytes(100);
//=> '100 B'
// Display with units of bits
prettyBytes(1337, {bits: true});
//=> '1.34 kbit'
// Display file size differences
prettyBytes(42, {signed: true});
//=> '+42 B'
// Localized output using German locale
prettyBytes(1337, {locale: 'de'});
//=> '1,34 kB'
// Fixed width for alignment (useful for progress bars and tables)
prettyBytes(1337, {fixedWidth: 8});
//=> ' 1.34 kB'
```
## API
### prettyBytes(number, options?)
#### number
Type: `number | bigint`
The number to format.
A `bigint` of any size is accepted. Past roughly `1e332` bytes the scaled value no longer fits a `number`, and it is written out in full from the exact quotient, so it carries no grouping and no localized decimal separator, the same as a value below `1e-100`.
Byte counts are otherwise formatted with the precision of a JavaScript number, which holds about 16 significant digits, so above roughly `1e17` bytes the trailing digits of the output may not be exact. A value that rounds up onto a unit boundary can therefore be printed in the larger unit, so `999499999999999999` bytes is `1 EB` rather than `999 PB`.
> [!NOTE]
> Rounding uses `Number#toPrecision`, so at an exact tie the direction comes from how that value is stored as a floating point number. `1005` bytes is `1.005 kB` and rounds down to `1 kB`, while `1125` bytes is `1.125 kB` and rounds up to `1.13 kB`.
#### options
Type: `object`
##### signed
Type: `boolean`\
Default: `false`
Include plus sign for positive numbers. If the difference is exactly zero a space character will be prepended instead for better alignment.
##### bits
Type: `boolean`\
Default: `false`
Format the number as [bits](https://en.wikipedia.org/wiki/Bit) instead of [bytes](https://en.wikipedia.org/wiki/Byte). This can be useful when, for example, referring to [bit rate](https://en.wikipedia.org/wiki/Bit_rate).
```js
import prettyBytes from 'pretty-bytes';
prettyBytes(1337, {bits: true});
//=> '1.34 kbit'
```
##### binary
Type: `boolean`\
Default: `false`
Format the number using the [Binary Prefix](https://en.wikipedia.org/wiki/Binary_prefix) instead of the [SI Prefix](https://en.wikipedia.org/wiki/SI_prefix). This can be useful for presenting memory amounts. However, this should not be used for presenting file sizes.
```js
import prettyBytes from 'pretty-bytes';
prettyBytes(1000, {binary: true});
//=> '1000 B'
prettyBytes(1024, {binary: true});
//=> '1 KiB'
```
##### locale
Type: `boolean | string | string[]`\
Default: `false`
- If `false`: Output won't be localized.
- If `true`: Localize the output using the system/browser locale.
- If `string`: Expects a [BCP 47 language tag](https://en.wikipedia.org/wiki/IETF_language_tag) (For example: `en`, `de`, …)
- If `string[]`: Expects a list of [BCP 47 language tags](https://en.wikipedia.org/wiki/IETF_language_tag) (For example: `en`, `de`, …)
> []
> Only the number and decimal separator are localized. The unit title is not and will not be localized.
> [!NOTE]
> A value below `1e-100` bytes needs more than the 100 fraction digits `Intl.NumberFormat` accepts, so it is written out with plain digits instead of a localized decimal separator.
```js
import prettyBytes from 'pretty-bytes';
prettyBytes(1337, {locale: 'de'});
//=> '1,34 kB'
```
##### minimumFractionDigits
Type: `number`\
Default: `undefined`
The minimum number of fraction digits to display.
If neither `minimumFractionDigits` nor `maximumFractionDigits` is set, the default behavior is to round to 3 significant digits.
Must be an integer between 0 and 100. Throws a `TypeError` for invalid values.
Must not be greater than `maximumFractionDigits`, which throws a `RangeError` when both are set.
> [!NOTE]
> When `minimumFractionDigits` or `maximumFractionDigits` is specified, values are truncated instead of rounded to provide more intuitive results for file sizes.
```js
import prettyBytes from 'pretty-bytes';
// Show the number with at least 3 fractional digits
prettyBytes(1900, {minimumFractionDigits: 3});
//=> '1.900 kB'
prettyBytes(1900);
//=> '1.9 kB'
```
##### maximumFractionDigits
Type: `number`\
Default: `undefined`
The maximum number of fraction digits to display.
If neither `minimumFractionDigits` nor `maximumFractionDigits` is set, the default behavior is to round to 3 significant digits.
Must be an integer between 0 and 100. Throws a `TypeError` for invalid values.
Must not be less than `minimumFractionDigits`, which throws a `RangeError` when both are set.
> [!NOTE]
> When `minimumFractionDigits` or `maximumFractionDigits` is specified, values are truncated instead of rounded to provide more intuitive results for file sizes.
```js
import prettyBytes from 'pretty-bytes';
// Show the number with at most 1 fractional digit
prettyBytes(1920, {maximumFractionDigits: 1});
//=> '1.9 kB'
prettyBytes(1920);
//=> '1.92 kB'
```
##### space
Type: `boolean`\
Default: `true`
Put a space between the number and unit.
```js
import prettyBytes from 'pretty-bytes';
prettyBytes(1920, {space: false});
//=> '1.92kB'
prettyBytes(1920);
//=> '1.92 kB'
```
##### nonBreakingSpace
Type: `boolean`\
Default: `false`
Use a non-breaking space instead of a regular space to prevent the unit from wrapping to a new line.
Has no effect when `space` is `false`.
```js
import prettyBytes from 'pretty-bytes';
prettyBytes(1337, {nonBreakingSpace: true});
//=> '1.34\u00A0kB'
prettyBytes(1337, {space: false, nonBreakingSpace: true});
//=> '1.34kB'
```
##### fixedWidth
Type: `number`\
Default: `undefined`
Pad the output to a fixed width by right-aligning it.
Useful for creating aligned columns in tables or progress bars.
If the output is longer than the specified width, no padding is applied.
Must be a non-negative integer. Throws a `TypeError` for invalid values.
```js
import prettyBytes from 'pretty-bytes';
prettyBytes(1337, {fixedWidth: 10});
//=> ' 1.34 kB'
prettyBytes(100_000, {fixedWidth: 10});
//=> ' 100 kB'
// Useful for progress bars and tables
[1000, 10_000, 100_000].map(bytes => prettyBytes(bytes, {fixedWidth: 8}));
//=> [' 1 kB', ' 10 kB', ' 100 kB']
```
## FAQ
### Why kB and not KB?
`k` is the [standardized SI prefix](https://en.wikipedia.org/wiki/Metric_prefix) for kilo.
## Related
- [pretty-bytes-cli](https://github.com/sindresorhus/pretty-bytes-cli) - CLI for this module
- [pretty-ms](https://github.com/sindresorhus/pretty-ms) - Convert milliseconds to a human readable string