Bytes
Deno module for easy handling of bytes and bits.
Roadmap
- Read/Write 8, 16, 24, 32 bit numbers
- Read/Write float32, float64
- Read/Write strings
- Read/Write 8, 16, 32, float32, float64, arrays
- Read/Write little endian for numbers
- Read/Write big endian for numbers
- Read/Write little endian for arrays
- Read/Write big endian for arrays
- BitSet class
- BitArray class
- ByteArray class - same as ByteSet but with dynamic expansion
Full documentation
Go here - https://doc.deno.land/https/deno.land/x/bytes/mod.ts
How to import
import { ByteSet, LengthType, NumberType } from "https://deno.land/x/bytes@1.0.3/mod.ts";
ByteSet
It’s byte array but with fixed size. Think of it as a wrapper for Uint8Array
. If you create a new ByteSet
from existing Uint8Array
it won’t create a copy of that array. It just wrap around. Each ByteSet
instance has a buffer, position, order and capacity.
// Buffer is some Uint8Array
const bytes = ByteSet.from(buffer);
// Write 1 byte
bytes.write.uint8(5);
console.log(buffer[0]); // 5
// Technically it's almost the same as buffer[n] = 5;
// But what if you need to store uint16 number in uint8array?
// Will you write buffer[0] = value & 0xff; buffer[1] = value >> 8; ?
// Or just bytes.write.uint16(16); ?
Examples
Basics
// Creates a byteset with static size
const a = new ByteSet(12);
// Or create from existing Uint8Array or ArrayBuffer
const b = ByteSet.from(new Uint8Array([1, 2, 3]));
How to read and write?
// Create set
const a = new ByteSet(1 + 2 + 4); // byte + short + int
// Write some numbers
a.write.uint8(1); // position = 1
a.write.uint16(512); // position = 3
a.write.uint32(100000); // position = 7
// Reset position for reading
a.position = 0;
console.log(a.read.uint8()); // 1
console.log(a.read.uint16()); // 512
console.log(a.read.uint32()); // 100000
Strings
// Create set
const a = new ByteSet(3); // length of string in bytes
a.write.string("Hi!");
// Reset position for reading
a.position = 0;
// Reads 3 bytes as string
console.log(a.read.string(3)); // Hi!
If you want to store length info to automatically reads it later you can pass LengthType
parameter.
// Create set
const a = new ByteSet(1 + 3); // length info + string
a.write.string("Hi!", LengthType.Uint8);
// Reset position for reading
a.position = 0;
// The lenth is unknown for you (for example)
// but you know that the LengthType is Uint8
console.log(a.read.string(LengthType.Uint8)); // Hi!
The second parameter is LengthType
. It can be None
, Uint8
, Uint16
or Uint32
. By default it’s None
so the length of the string can be any size but unknown for you. If you use Uint8
you can store up until 255
bytes string. If use Uint16
then up until 65335
. When you read string you can pass LengthType
or specific size.
Technically LengthType
just put bytes before string that contains length of string. When you read string with LengthType.Uint8
it will read 1
byte that contains length. Then it will read full string with that length.
Note! String function will store any string as utf-8
string. So when you read and write strings the length doesn’t mean length of string it means length of bytes of that string.
Arrays
You can also write and read some typed arrays. For example
// Create set
const b = new ByteSet(4); // because each number is 2 bytes
b.write.int16Array(new Int16Array([512, 2048]));
// Reset position for reading
b.position = 0;
const a = b.read.int16Array(2);
console.log(a[0]); // 512
console.log(a[1]); // 2048
By default it won’t store length information. If you want to store length you can use this.
const b = new ByteSet(4);
b.write.uint8Array(new Uint8Array([1, 2, 3]), LengthType.Uint8);
// Reset position for reading
b.position = 0;
// The lenth is unknown for you (for example)
// but you know that the length info is in uint8
const a = b.read.uint8Array(LengthType.Uint8);
console.log(a[0]); // 1
console.log(a[1]); // 2
console.log(a[2]); // 3
console.log(a.length); // 3
The same logic goes for LengthType.Uint16
and LengthType.Uint32
and for other typed arrays too.
Other examples
const b = new ByteSet(4);
b.write.uint8Array(new Uint8Array([1, 2, 3]));
// Reset position for reading
b.position = 0;
// You can read each uint8 from current position
b.read.each(NumberType.Uint8, (x) => {
console.log(x);
});
// It will output
// 1
// 2
// 3
// 0
// Why zero at the end? Becase size of set is 4.
// And we wrote only 3 numbers. By default array contains 0 values.