BufferJs
An easy yet complete to use iterable data buffer in javascript
Ideal for parsing text data or tokens.
Works with any array-like data.
Compatible with both JavaScript and TypeScript
Installation
Download from CDN or install from npm
npm install --save buffingjs
Usage
Basic Example
import { BufferJs } from 'buffingjs';
// Or for javascript
// const BufferJs = require('buffingjs');
const hugeText = `At vero eos et accusamus et iusto odio dignissimos ducimus qui blanditiis praesentium.
voluptatum deleniti atque corrupti quos dolores et quas molestias excepturi sint occaecati?
cupiditate non provident, similique sunt in culpa qui officia deserunt mollitia animi, id est
laborum et dolorum fuga.`;
const textBuffer = new BufferJs(hugeText);
const list = [1, 2, 3, 4, 5, 6];
const listBuffer = new BufferJs(list);Moving the cursor
import { BufferJs } from 'buffingjs';
// Or for javascript
// const BufferJs = require('buffingjs');
const data = ['A', 'B', 'C', 'D', 'E'];
const buffer = new BufferJs(code);
console.log(buffer.current); // 'A'
console.log(buffer.next); // 'B'
console.log(buffer.prev); // undefined
buffer.consume(2); // Same as calling buffer.toNext() twice
console.log(buffer.current); // 'C'
console.log(buffer.next); // 'D'
console.log(buffer.prev); // 'B'
console.log(buffer.toPrev()); // 'B'
console.log(buffer.current); // 'B'
console.log(buffer.next); // 'A'
console.log(buffer.prev); // 'C'
console.log(buffer.position); // 1
buffer.seek(2);
console.log(buffer.position); // 2
console.log(buffer.current); // 'C'
console.log(buffer.next); // 'D'
console.log(buffer.prev); // 'B'Parsing
import { BufferJs } from 'buffingjs';
// Or for javascript
// const BufferJs = require('buffingjs');
const code = `1+2 - 3 * 5 / 823 + 2.501`;
const buffer = new BufferJs(code);
const regexNumbers = /[\d\.]/;
function parseNumbers() {
let readDot = false;
const value = buffer.extract(c => {
if (c === '.') {
if (readDot) {
return false;
}
readDot = true;
}
return regexNumbers.test(c);
}).join('');
return {
type: 'number',
value: parseFloat(value)
};
}
const regexOperators = /^(?:\+|\-|\*|\/|>|<|(?:>>)|(?:<<))$/;
function parseOperators() {
let value = '';
buffer.iterate(c => {
const _possibleMatch = value + c;
if (!regexOperators.test(_possibleMatch)) {
return false;
}
value = _possibleMatch;
return true;
});
return {
type: 'operator',
value
};
}
const tokens = [];
buffer.forEach(current => {
if (regexNumbers.test(current)) {
tokens.push(parseNumbers());
} else if (regexOperators.test(current)) {
tokens.push(parseOperators());
}
});
console.log(tokens);Buffer Api
export
class Buffer
template T
Constructors
constructor
+ new Buffer(data: ArrayLike‹T›): Buffer
Creates an instance of Buffer.
Parameters:
| Name | Type |
|---|---|
data |
ArrayLike‹T› |
Returns: Buffer
Accessors
current
• get current(): T | undefined
The value at the current position
readonly
type (T | undefined)
Returns: T | undefined
hasCurrent
• get hasCurrent(): boolean
Verify if there is a value to read at the current position
readonly
Returns: boolean
hasNext
• get hasNext(): boolean
Verify if there is a value to read at the next position
readonly
type boolean
Returns: boolean
hasPrev
• get hasPrev(): boolean
Verify if there is a value to read at the previous position
readonly
type boolean
Returns: boolean
length
• get length(): number
The length of the buffer
readonly
type number
Returns: number
next
• get next(): T | undefined
The next value
readonly
type (T | undefined)
Returns: T | undefined
position
• get position(): number
The current position number
readonly
type number
Returns: number
prev
• get prev(): T | undefined
The previous read value
readonly
type (T | undefined)
Returns: T | undefined
Methods
at
▸ at(pos: number, mode?: "absolute" | "relative"): T | undefined
Returns the value at position [pos] If mode is 'relative' it is considered from the current position instead of 0 Negative values are accepted in the 'relative' mode In the 'absolute' mode negative values will always yield undefined
Parameters:
| Name | Type |
|---|---|
pos |
number |
mode? |
"absolute" | "relative" |
Returns: T | undefined
consume
▸ consume(count?: undefined | number): void
Consume the value at the current position and move [count] times Negative values are accepted and move backwards instead
Parameters:
| Name | Type |
|---|---|
count? |
undefined | number |
Returns: void
drop
▸ drop(): void
Remove the latest saved position from the stack
Returns: void
extract
▸ extract(filter: function): T[]
Iterate from the current position untill [filter] return false or there is no data to process anymore Return the iterated data
Parameters:
▸ (next: T, pos: number): boolean
Parameters:
| Name | Type |
|---|---|
next |
T |
pos |
number |
Returns: T[]
forEach
▸ forEach(callback: function): T[]
If the buffer does not change it is position inside the callback
this.consume will be called to ensure an infinite loop is not created by mistake
Parameters:
▸ (next: T, pos: number): void
Parameters:
| Name | Type |
|---|---|
next |
T |
pos |
number |
Returns: this
iterate
▸ iterate(filter: function): this
Iterate from the current position untill [filter] return false or there is no data to process anymore
Parameters:
▸ (next: T, pos: number): boolean
Parameters:
| Name | Type |
|---|---|
next |
T |
pos |
number |
Returns: this
join
▸ join(sep: string): string
Join the data into a string using the separator [sep]
Parameters:
| Name | Type |
|---|---|
sep |
string |
Returns: string
restore
▸ restore(): void
Restore to the latest saved position The position is removed from the stack
Returns: void
rewind
▸ rewind(): void
Return to the starting position of the buffer
Returns: void
save
▸ save(): void
Save the current position for later Saved positions are stored in stack
Returns: void
seek
▸ seek(pos?: undefined | number): void
Change the current position number to [pos] Values bigger than the buffer legth or less than 0 will be forced to stay in the range
Parameters:
| Name | Type |
|---|---|
pos? |
undefined | number |
Returns: void
toArray
▸ toArray(): T[]
Returns: T[]
toNext
▸ toNext(): T | undefined
Move to the next position and then return the value
Returns: T | undefined
toPrev
▸ toPrev(): T | undefined
Move to the previous position and then return the value
Returns: T | undefined
toString
▸ toString(): string
Return the string representation of the data
Returns: string