NodeJS Byte Parser Parse bytes to human readable sizes (4747) → ('4.75 KB') and vice versa.
Via NPM:
npm install xbytes
// Node CommonJS
const xbytes = require('xbytes');
// Or Node ES6 Modules
import xbytes from 'xbytes';
// Or TypeScript
import * as xbytes from 'xbytes';
<!-- Or in the Browser -->
<script src="xbytes/dist/index.js"></script>
xbytes(4747); // '4.75 KB'
xbytes(-3946); // '-3.95 KB'
xbytes(34.724e+4); // '347.24 KB'
xbytes(32000000000); // '32.00 GB'
xbytes(21474836480, {iec: true}); // '20.00 GiB'
xbytes.parseSize('10 GB'); // 10000000
xbytes.parseSize('-50 GiB'); // -53687091200
IEC Specification*
xbytes(5242880, {iec: true}); // '5 MiB'
xbytes.parseSize('10 GiB'); // 10485760
byte: <number>options: <ByteOptions>Parse byte to human readable size. If byte is not a number or an number-like string, return null appropriately.
xbytes(2472946)
// << '2.47 MB'
xbytes(49392123904, {iec: true})
// << '46.00 GiB'
str: <ByteString>config: <ParseOptions>Parse human readable size to bytes
xbytes.parseSize('15.967 MB')
// << 15967000
xbytes.parseSize('5.97 PiB')
// << 6721622443850465
str: <HybridByte>Create a ByteUnitObject around the specified HybridByte
xbytes.parse('10 MiB')
// << ByteUnitObject { bytes: 10485760 }
xbytes.parse('10 MiB').add('20 MiB')
// << ByteUnitObject { bytes: 31457280 }
xbytes.parse('10 MiB').add('20 MiB').toIECBytes()
// << '30.00 MiB'
Check if the provided string is a ByteString
xbytes.isBytes('10 MiB')
// << true
xbytes.isBytes('Hello')
// << false
xbytes.isBytes('10 iB')
// << false
xbytes.isBytes('10b')
// << true
str: <UnitString>Check if the provided string is an UnitString
xbytes.isUnit('GB')
// << true
xbytes.isUnit('giB')
// << true
xbytes.isUnit('iB')
// << false
xbytes.isUnit('BB')
// << false
input: <HybridByte>Check if the provided argument is parsable i.e raw_bytes (number) or ByteString.
size: <HybridByte>options: <ByteOptions>size: <HybridByte>options: <ByteOptions>Show the input size in relation to its bit format
size: <HybridByte>options: <ByteOptions>Show the input size in relation to its byte format
size: <HybridByte>options: <ByteOptions>Show the input size in relation to its bit format under IEC Standards
size: <HybridByte>options: <ByteOptions>Show the input size in relation to its bytes format under IEC Standards
size: <HybridByte>unit: <UnitString>options: <ByteOptions>str: <ByteString>Parse a human readable byte into its components
str: <HybridByte>options: <ByteOptions>Parse a human readable byte into its components.
Extended from parseString(), but with a few extra properties.
And flexibility to use parse either an integer byte value or a ByteString resulting in the same object.
str: <string>Extract all ByteStrings within a string into an array, alternative to str.match(xbytes.byteFilter)
config: <ByteOptions>Construct a static ByteParser with predefined configurations
config: <ParseOptions>Construct a static SizeParser with predefined configurations
unit: <UnitString>config: <ByteOptions>Create a RelativeSizer for converting a hybrid byte into any set unit under predefined configuration
RegExpThe raw Regular expression used in scanning all string byte units.
RegExpThe raw regular expression used in scanning all byte containing strings.
RegExpAn regular expression extension of genericMatcher with the 'i' flag.
RegExpAn regular expression extension of genericMatcher with the 'gi' flags.
StringSupported Unit Strings
| Index | Prefix | Decimal Bits | Binary Bits (IEC) | Decimal Bytes | Binary Bytes (IEC) |
|---|---|---|---|---|---|
| 0 | - | b (Bits) | b (Bits) | b (Bits) | b (Bits) |
| 0 | - | B (Bytes) | B (Bytes) | B (Bytes) | B (Bytes) |
| 1 | K | Kb (KiloBits) | Kib (KiloBits) | KB (KiloBytes) | KiB (KibiBytes) |
| 2 | M | Mb (MegaBits) | Mib (MebiBits) | MB (MegaBytes) | MiB (MebiBytes) |
| 3 | G | Gb (GigaBits) | Gib (GibiBits) | GB (GigaBytes) | GiB (GibiBytes) |
| 4 | T | Tb (TeraBits) | Tib (TebiBits) | TB (TeraBytes) | TiB (TebiBytes) |
| 5 | P | Pb (PetaBits) | Pib (PebiBits) | PB (PetaBytes) | PiB (PebiBytes) |
| 6 | E | Eb (ExaBits) | Eib (ExbiBits) | EB (ExaBytes) | EiB (ExbiBytes) |
| 7 | Z | Zb (ZettaBits) | Zib (ZebiBits) | ZB (ZettaBytes) | ZiB (ZebiBytes) |
| 8 | Y | Yb (YottaBits) | Yib (YobiBits) | YB (YottaBytes) | YiB (YobiBytes) |
StringA stringed byte representation. The result of a parsed byte value.
Number|ByteStringUsed to identify a variable thats either a ByteString or a number
Objectiec: <boolean> Whether or not to parse under the IEC standard i.e in terms of 1024. Default: truebits: <boolean> Whether or not to convert inputed bytes to bits and parse in terms of bits [1 byte = 8 bits]. Default: false.fixed: <number> Number of digits to include after decimal point. Default: 2.short: <boolean> Whether or not to shorten unit String [short: 'MB', long: 'MegaBytes']. Default: true.space: <boolean> Whether or not to include a white space inbetween value and unit. Default: true.sticky: <boolean> Whether or not to retain unit on max unit values. e.g '1024.00 GiB' instead of '1.00 TiB'. Default: false.prefixIndex: <number> The index of unit relativity [See UnitString].Objectiec: <boolean> Whether or not to enforce compliance to IEC standards. Default: true.bits: <boolean> Whether or not to parse a lower case 'b' in bit format. Default: true.Functionsize: <number>Byte parser with predefined configuration. Result of createByteParser.
Functionstr: <ByteString[]>ByteString parser with predefined configuration. Result of createSizeParser.
Functionsize: <HybridByte>HybridByte parser with predefined configuration. Result of createRelativeSizer.
Objectiec: <boolean> Whether or not the byte is represented under the IEC standard i.e in terms of 1024.
true in '7 TiB'false in '3 TB'type: <string> Whether the size is represented as bits(b) or bytes(B).
'b' in '499Yb''B' in '7 MB'bits: <boolean> Whether or not the size is specifically represented as a bit.
true in 84 Ybfalse in 278.58 KBbytes: <boolean> Whether or not the size is specifically represented as a byte.
true in 92 EBfalse in 28 Mbunit: <UnitString> Re-parsed UnitString of inputUnit, fixing formatting.
'TB' if 'TB''Gib' if 'gib'inputUnit: <UnitString> The unparsed String as was provided.
'47TB' in '47TB'prefix: <string> The prefix of the size string.
'K' in 'KB'prefixIndex: <number> The index of the size unit [See UnitString].
3 in 'GB'extends ParsedUnit: Objectinput: <ByteString> The unparsed String as was provided.
'47TB' in '47TB'value: <number> The value for the size.
83 in '83MB'extends ParsedByteString: Objectinput: <HybridByte> The unparsed String as was provided.
1024 in 1024'47TB' in '47TB'size: <ByteString> The value for the size.
83 in '83MB'bytes: <number> The value for the size.
10485760 from '10 MiB'bytes: <number> Internal byte value.Wrap a HybridByte in a chainable, transformative object.
new ByteUnitObject('10 MiB')
// << ByteUnitObject { bytes: 10485760 }
new ByteUnitObject('10 MiB').add('20 MiB')
// << ByteUnitObject { bytes: 31457280 }
new ByteUnitObject('10 MiB').add('20 MiB').toIECBytes()
// << '30.00 MiB'
bytes: <HybridByte|HybridByte[]> Byte(s) to subract from the root byte.Add byte(s) to the internal bytes, resulting in a new ByteUnitObject object with the value
bytes: <HybridByte|HybridByte[]> Subtract byte(s) from the internal bytes, resulting in a new ByteUnitObject object with the value.Subtract byte(s) from the internal bytes, resulting in a new ByteUnitObject object with the value
bytes: <HybridByte|HybridByte[]> Multiply byte(s) with the internal bytes, resulting in a new ByteUnitObject object with the value.Multiply byte(s) with the internal bytes, resulting in a new ByteUnitObject object with the value
bytes: <HybridByte|HybridByte[]> Byte(s) to divide with.Divide internal bytes by byte(s) specified, resulting in a new ByteUnitObject object with the value
unit: <UnitString>Parse the internal byte into any unit, following the relativity.
new ByteUnitObject('10 MiB')
// >> ByteUnitObject { bytes: 10485760 }
new ByteUnitObject('10 MiB').convertTo('MB')
// >> '10.49 MB'
new ByteUnitObject('10 MiB').add('50 MB').convertTo('KB')
'60485.76 KB'
opts: <ByteOptions>Parse the internal bytes property to a byte object.
Method to check integrity of internal bytes. Throw if there's an error somewhere.
Objectraw: <HybridByte> The unparsed databits: <ByteString> A relative bit parsing of the input HybridBytesize: <number> The numeric byte format of the input HybridBytebytes: <ByteString> A relative byte parsing of the input HybridByteiecBits: <ByteString> A relative bit parsing of the input HybridByte under the IEC Specificationparsed: <ByteString> A relative bit parsing of the input HybridByte under the IEC SpecificationiecBytes: <ByteString> A relative byte parsing of the input HybridByte under the IEC SpecificationCheck out some examples in the examples folder
$ node examples/index.js 'Hey, its 6GB, but my 8 TB flash drive is better'
┌─────────┬──────────┬───────────┬────────┬───────────┬────────────┬────────────┬─────────────┐
│ (index) │ parsed │ size │ raw │ bytes │ iecBytes │ bits │ iecBits │
├─────────┼──────────┼───────────┼────────┼───────────┼────────────┼────────────┼─────────────┤
│ 0 │ [Object] │ '6.00 GB' │ '6GB' │ '6.00 GB' │ '5.59 GiB' │ '48.00 Gb' │ '44.70 Gib' │
│ 1 │ [Object] │ '8.00 TB' │ '8 TB' │ '8.00 TB' │ '7.28 TiB' │ '64.00 Tb' │ '58.21 Tib' │
└─────────┴──────────┴───────────┴────────┴───────────┴────────────┴────────────┴─────────────┘
$ node examples/parse.js 'The 10GB file was downloaded in 50MB/s'
The 10737418240 file was downloaded in 52428800/s
$ node examples/relative.js mb '10GiB, 1mb 6 gb'
85899.35 Mb, 1.00 Mb 6000.00 Mb
$ node examples/random.js 10 // Parse 10 random bytes
[tabular data]
$ node examples/extract.js 'Hey, its 6GB, but my 8 TB flash drive is better'
┌─────────┬────────┬───────────────┐
│ (index) │ size │ bytes │
├─────────┼────────┼───────────────┤
│ 0 │ '6GB' │ 6000000000 │
│ 1 │ '8 TB' │ 8000000000000 │
└─────────┴────────┴───────────────┘
$ nvm exec v1.8.4 node -pe 'require(".")(3748587)'
"3.75 MB"
$ nvm exec v5.12.0 node -pe 'require(".").parseSize("476 TiB")'
523367534821376
$ nvm exec v11.10.0 node -e '
let xbytes = require("./dist");
let str = "My 10GB drive transmits at 250MiB/sec"
console.log(str.replace(xbytes.globalByteFilter, xbytes.relative.bits))
'
"My 80.00 Gb drive transmits at 2.10 Gb/sec"
xbytes(524334545.847775856); // 524.33 MB
xbytes.parseSize('665.284 TiB'); // 731487493773328.4
xbytes(.24283884748955); // 0.24 B
xbytes.parseSize('.295 MB'); // 295000
xbytes.parseSize('1 MiB'); // 1048576
xbytes(50000000, {short: false}); // '50.00 MegaBytes'
let data = 'My 16GB flash drive has a 4GB Zip Archive and a 5MB JavaScript file';
xbytes.extractBytes(data);
//> [ '16GB', '4GB', '5MB' ]
data.match(xbytes.globalByteFilter)
//> [ '16GB', '4GB', '5MB' ]
data.replace(xbytes.globalByteFilter, xbytes.parseSize)
//> 'My 16000000000 flash drive has a 4000000000 Zip Archive and a 5000000 JavaScript file'
data.replace(xbytes.globalByteFilter, xbytes.createSizeParser({ iec: false }))
//> 'My 17179869184 flash drive has a 4294967296 Zip Archive and a 5242880 JavaScript file'
import { parseSize, relative } from 'xbytes';
relative('35 TiB').bits // '307.86 Tb'
relative('35 TiB').bytes // '38.48 TB'
relative('35 TiB').iecBits // '280.00 Tib'
relative('35 TiB').iecBytes // '35.00 TiB'
parseSize(relative('35 TiB', {fixed: 20}).bits);
//> 38482906972160
parseSize(relative('35 TiB', {fixed: 20}).bytes);
//> 38482906972160
parseSize(relative('35 TiB', {fixed: 20}).iecBits);
//> 38482906972160
parseSize(relative('35 TiB', {fixed: 20}).iecBytes);
//> 38482906972160
Feel free to clone, use in adherance to the license and perhaps send pull requests
git clone https://github.com/miraclx/xbytes.git
cd xbytes
npm install
# hack on code
npm run build
npm test
Tests are executed with Jest. To use it, simple run npm install, it will install
Jest and its dependencies in your project's node_modules directory followed by npm run build and finally npm test.
To run the tests:
npm install
npm run build
npm test
Apache 2.0 © Miraculous Owonubi (@miraclx) <omiraculous@gmail.com>
FAQs
Parse bytes to human readable sizes (4747) → ('4.75 KB') and vice versa.
The npm package xbytes receives a total of 17,865 weekly downloads. As such, xbytes popularity was classified as popular.
We found that xbytes demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
PyPI confirms no security flaws were exploited in the Ultralytics supply chain attack and highlights improvements for safer package publishing.
Security News
Research
The Socket Research Team breaks down a malicious wrapper package that uses obfuscation to harvest credentials and exfiltrate sensitive data.
Research
Security News
Attackers used a malicious npm package typosquatting a popular ESLint plugin to steal sensitive data, execute commands, and exploit developer systems.