A seamless implementation of a BitArray for Javascript
npm install @ascari/bitarrayA BitArray works like a regular Array object. In fact, anything you can do with Arraysindex.Of lastIndexOf slice splice join reverse filter sort etc
you can do with a BitArray instance. Keep in mind that the elements will always be a numeric 0 or a 1.
As it's still impossible to inherit from the Array object, to take advantage of the bracket syntax i.e. customArray[index], as explained in the article by perfectionkills:
> Subclassing an array in Javascript has never been a trivial task.
> At least for a certain meaning of “subclassing an array”. Curiously,
> new edition of the language — ECMAScript 5 — still does not allow
> to fully subclass an array.
Direct property injection is used, as it is the only reliable choice.
#### Browser
``html`
All ES5 Array methods are supported
`js
var buffer = new BitArray(1,1,0,0)
console.log(buffer[0], buffer[1], buffer[2], buffer[3]) // 1 1 0 0
buffer.push(1, 0, 1, 0, 1)
console.log(buffer) // [1,1,0,0,1,0,1,0,1]
buffer.push(1, 1, 1, 1, 1)
console.log(buffer) // [1,1,0,0,1,0,1,0,1,1,1,1,1,1]
buffer.length = 0 // []
buffer.push('A') // 65. characters are stored in 16 bits
console.log(buffer) // [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1]
buffer.pop()
buffer.pop()
console.log(buffer) // [0,0,0,0,0,0,0,0,0,1,0,0,0,0]
buffer.unshift(1,1,1)
console.log(buffer) // [1,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0]
// Lets go nuts
buffer.length = 0 // []
buffer.push(1,0,1,1,1, 'Hello World', 255, 0xFFFF, 0, true, false, 1, 0, 1, 0)
console.log(buffer) // See Accepted Types
// [1,0,1,1,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,
// 0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,
// 0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,
// 0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,1,1,0,0,0,0,0,0,0,0,0,1,1,
// 0,1,1,1,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,
// 0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,1,0,0,0,1,0,1,0,1,0]
`
NOTE
Javasciript uses 16 bits for a single character from the most common characters defined by the UCS-2 standard a subset of UTF-16. All characters are treated as 16 bits. reference
The Array equivalant methods defined by the BitArray, will resolve values in the following order:
typeof value === 'string'
Treat each character as its 16 bit character code
typeof value === 'boolean'
Treat each value as either a 1 or a 0
typeof value === 'number'
If number is a 0 or 1, it is treated as a single bit.
else
The number is treated as a ~64 bit number...
almost 64bits, the number has to be less than 0xFFFFFFFFFFFFFBFF
(18446744073709550000. instead of 18446744073709552000.)
#### When in doubt, be specific:
NOTICE Specifiers have not been implemented yet, they are in the kitchen, on their way out. Specifiers will become a postfix to common Array-equivalent methods, this is simply to enforce a particular type of input, since a Number, for example can be a single bit or 64 bits depending on it's value, this may cause conflift, hence the specifiers.
`
buffer.pushBit(1) // 1 bit
buffer.pushBit(1, 0, 1) // 3 bits
buffer.pushChar('A') // 16 bits
buffer.pushString('Awesome') // (16 * .length) bits`
buffer.pushNumber(1) // 64 bits
buffer.pushUInt32(0xFFFF44) // 32 bits
All The Array equivalant methods will have more specific counterparts where the type is explicit, e.g.
unshiftBit popBit spliceBit joinNumber forEachBit sliceNumber join32UInt indexOfString sliceBit spliceString joinChar findBit
Everything is treated as bits internally, so when using lastIndexOfString for example, the string being searched for will be converted to binary, and a binary search will be done. This is true for all iterating methods: indexOfChar forEachString findChar etc
The idea is to iterate the internal bits in a BitArray while treating them as bytes, words and even strings, depending on the postfix applied.
Use any postfix on a method if you want to work on the internal bits as specific bit structure
BitArray.
| postfix | bit size | alias | accepted types
|----------|------------------|-----------------------------|------------------------------------|
| Bit | 1 | Bits | number
| Char | 16 | Character | string (only first character)
| String | length 16 | Str | string*
| Date | 64 | | instanceof Date
| Number | 64 | 64Uint Qword QWORD | number (0 - 18446744073709550000)
| UInt32 | 32 | Dword DWORD | number (0 - 4294967295)
| UInt16 | 16 | Word WORD | number (0 - 65535)
| UInt8 | 8 | Byte BYTE | number (0 - 255)
| Array | length 1 | | instanceof each element is a bit*
| BitArray | length 1 | | BitArray.isBitArray()*
Note When only a number is an accepted type, it can be a Numeric string as well as a boolean, as it will be casted into a number.
When using a specifier, if the argument is not a supported type, it will throw
BitArray has the following static methods that allow you to create a new BitArray from different types:
Boolean BitArray.isBitArray(Object)
Test if object is a BitArray
BitArray BitArray.fromNumber(Number)
Convert a number into a 64 bit BitArray
BitArray BitArray.fromString(String)
Convert a string into a BitArray
BitArray BitArray.fromArray(Array)
Convert an array of 0s and 1s into a BitArray
BitArray BitArray.fromMixedArray(Array)
Convert an array of mixed element types (and bit sizes), into a BitArray
BitArray BitArray.fromDate(Date)
Convert a date into a 64 bit BitArray
BitArray BitArray.fromBoolean(Boolean)
Convert a boolean into a 1 bit BitArray
Documentation is generated with the very awesome yuidoc
make sure it's installed:
npm yuidoc -g
And run the following command in the root folder to create a folder called documentation
yuidoc
Testing is done with mocha, make sure it's installed:
npm i mocha -g
and run the tests found inside the test` folder with
mocha
- Include Specifiers and their alias
- Conversion from and to types including Typed Arrays
- Bit manipulation methods (rotr, xor, etc)
- Node.js streaming
- ES6 support (shims & implementation)
- ES5 shims, in case they are ever needed