Returns the number of elements in this hashmap.

const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const size = hashmap.size;
console.log(size);
// logs: 3

Returns the number of elements in this hashmap.

const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const length = hashmap.length;
console.log(length);
// logs: 3

Does the map have this key.

• return true if the key is in the map.
• if no elements match, it returns false.
• it is legitimate for keys to be null or undefined.

Maps typically index keys, and so is generally a fast operation.

Does this contain a key that is there

const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const hasResult = hashmap.has(1);
// hasResult === true

Does this contain a key that isn't there

const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const hasResult = hashmap.has(4);
// hasResult === false

Advanced: using a predefined hashCode and equals on the key

class NameKey {
    constructor(firstName, secondName) {
        this.firstName = firstName;
        this.secondName = secondName;
    }
    hashCode() {
         return (Mootable.hash(firstName) * 31) +Mootable.hash(secondName);
    }
    equals(other) {
         return other && other instanceof NameKey && other.firstName === this.firstName && other.secondName === this.secondName;
    }
}
const hashmap = new HashMap([[new NameKey('John','Smith'),'Librarian'],[new NameKey('Orlando','Keleshian'),'Engineer']]);
const key = new NameKey('John','Smith');
const hasResult = hashmap.has(key);
// hasResult === true

Advanced: using a custom hash and equals, to determine if there are entries for a specific hash

const myHash = 3;
const hashEquals = {hash: myHash, equals: () => true}
const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const hasResult = hashmap.has(0, hashEquals);
// hasResult === true
// the hash of the number 3 is actually also 3. all 32 bit integers have the same hash.
// 0 doesn't exist in the hashMap, but we are circumventing using the key entirely.

Get a value from the map using this key.

• return the first value from the [key,value] pair that matches the key.
• if no elements match, it returns undefined.
• it is legitimate for keys to be null or undefined, and if set, will find a value.
• it is also legitimate for values to be null or undefined, as such get should never be used as an existence check. {@see HashMap#optionalGet}

Also provides a way to override both the equals and the hash Performance:

• will be O(1) approaching O(log n)

What is the value for a key

const hashmap = new LinkedHashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const getResult = hashmap.get(1);
// getResult === 'value1'

What is the value for a key that isn't there

const hashmap = new LinkedHashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const getResult = hashmap.get(4);
// getResult === undefined

Advanced: using a predefined hashCode and equals on the key

class NameKey {
    constructor(firstName, secondName) {
        this.firstName = firstName;
        this.secondName = secondName;
    }
    hashCode() {
         return (Mootable.hash(firstName) * 31) +Mootable.hash(secondName);
    }
    equals(other) {
         return other && other instanceof NameKey && other.firstName === this.firstName && other.secondName === this.secondName;
    }
}
const hashmap = new HashMap([[new NameKey('John','Smith'),'Librarian'],[new NameKey('Orlando','Keleshian'),'Engineer']]);
const key = new NameKey('John','Smith');
const getResult = hashmap.get(key);
// getResult === 'Librarian'

Advanced: using a custom hash and equals, to get the first entry for a specific hash

const myHash = 3;
const hashEquals = {hash: myHash, equals: () => true}
const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const getResult = hashmap.get(0, hashEquals);
// getResult === 'value3'
// the hash of the number 3 is actually also 3. all 32 bit integers have the same hash.
// 0 doesn't exist in the hashMap, but we are circumventing using the key entirely.

Get the key from the map using the provided value. Since values are not hashed, this has to check each value in the map until a value matches, or the whole map, if none match. As such this is a slow operation. Performance O(n) as we have to iterate over the whole map, to find each value and perform an equality against it.

What is the key for a value

const hashmap = new LinkedHashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const keyOfResult = hashmap.keyOf('value2');
// keyOfResult === 2

What is the value for a key that isn't there

const hashmap = new LinkedHashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const keyOfResult = hashmap.keyOf('value4');
// keyOfResult === undefined

Advanced: using a predefined hashCode and equals on the key

class NameKey {
    constructor(firstName, secondName) {
        this.firstName = firstName;
        this.secondName = secondName;
    }
    hashCode() {
         return (Mootable.hash(firstName) * 31) +Mootable.hash(secondName);
    }
    equals(other) {
         return other && other instanceof NameKey && other.firstName === this.firstName && other.secondName === this.secondName;
    }
}
const hashmap = new HashMap([[new NameKey('John','Smith'),'Librarian'],[new NameKey('Orlando','Keleshian'),'Engineer']]);
const keyOfResult = hashmap.keyOf('Engineer');
// getResult ~ NameKey('Orlando','Keleshian')

Advanced: using a custom equals, to get the first key in the hashmap

const myEquals = {equals: () => true}
const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const keyOfResult = hashmap.keyOf(0, myEquals);
// keyOfResult === 1
// 0 doesn't exist in the hashMap, but we are circumventing using the key entirely.

Get the key from the map using the provided value, searching the map in reverse. Since values are not hashed, this has to check each value in the map until a value matches, or the whole map, if none match. As such this is a slow operation. Performance O(n) as we have to iterate over the whole map, to find each value and perform an equality against it.

What is the key for a value

const hashmap = new LinkedHashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const lastKeyOfResult = hashmap.lastKeyOf('value2');
// lastKeyOfResult === 2

What is the value for a key that isn't there

const hashmap = new LinkedHashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const lastKeyOfResult = hashmap.lastKeyOf('value4');
// lastKeyOfResult === undefined

Advanced: using a predefined hashCode and equals on the key

class NameKey {
    constructor(firstName, secondName) {
        this.firstName = firstName;
        this.secondName = secondName;
    }
    hashCode() {
         return (Mootable.hash(firstName) * 31) +Mootable.hash(secondName);
    }
    equals(other) {
         return other && other instanceof NameKey && other.firstName === this.firstName && other.secondName === this.secondName;
    }
}
const hashmap = new HashMap([[new NameKey('John','Smith'),'Librarian'],[new NameKey('Orlando','Keleshian'),'Engineer']]);
const lastKeyOfResult = hashmap.lastKeyOf('Engineer');
// getResult ~ NameKey('Orlando','Keleshian')

Advanced: using a custom equals, to get the last key in the hashmap

const myEquals = {equals: () => true}
const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const lastKeyOfResult = hashmap.lastKeyOf(0, myEquals);
// lastKeyOfResult === 3
// 0 doesn't exist in the hashMap, but we are circumventing using the key entirely.

Get the key from the map using the provided value, and wrap it in an Option. Since values are not hashed, this has to check each value in the map until a value matches, or the whole map, if none match. As such this is a slow operation. Performance O(n) as we have to iterate over the whole map, to find each value and perform an equality against it.

What is the key for a value

const hashmap = new LinkedHashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const optionalKeyOfResult = hashmap.optionalKeyOf('value2');
// optionalKeyOfResult === Option.some(2)

What is the value for a key that isn't there

const hashmap = new LinkedHashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const optionalKeyOfResult = hashmap.optionalKeyOf('value4');
// optionalKeyOfResult === Option.none

Advanced: using a predefined hashCode and equals on the key

class NameKey {
    constructor(firstName, secondName) {
        this.firstName = firstName;
        this.secondName = secondName;
    }
    hashCode() {
         return (Mootable.hash(firstName) * 31) +Mootable.hash(secondName);
    }
    equals(other) {
         return other && other instanceof NameKey && other.firstName === this.firstName && other.secondName === this.secondName;
    }
}
const hashmap = new HashMap([[new NameKey('John','Smith'),'Librarian'],[new NameKey('Orlando','Keleshian'),'Engineer']]);
const optionalKeyOfResult = hashmap.optionalKeyOf('Engineer');
// getResult ~ Option.some(NameKey('Orlando','Keleshian'))

Advanced: using a custom equals, to get the first key in the hashmap

const myEquals = {equals: () => true}
const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const optionalKeyOfResult = hashmap.optionalKeyOf(0, myEquals);
// optionalKeyOfResult === Option.some(1)
// 0 doesn't exist in the hashMap, but we are circumventing using the key entirely.

Get the key from the map using the provided value, searching the map in reverse. Since values are not hashed, this has to check each value in the map until a value matches, or the whole map, if none match. As such this is a slow operation. Performance O(n) as we have to iterate over the whole map, to find each value and perform an equality against it.

What is the key for a value

const hashmap = new LinkedHashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const optionalLastKeyOfResult = hashmap.optionalLastKeyOf('value2');
// optionalLastKeyOfResult === Option.some(2)

What is the value for a key that isn't there

const hashmap = new LinkedHashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const optionalLastKeyOfResult = hashmap.optionalLastKeyOf('value4');
// optionalLastKeyOfResult === Option.none

Advanced: using a predefined hashCode and equals on the key

class NameKey {
    constructor(firstName, secondName) {
        this.firstName = firstName;
        this.secondName = secondName;
    }
    hashCode() {
         return (Mootable.hash(firstName) * 31) +Mootable.hash(secondName);
    }
    equals(other) {
         return other && other instanceof NameKey && other.firstName === this.firstName && other.secondName === this.secondName;
    }
}
const hashmap = new HashMap([[new NameKey('John','Smith'),'Librarian'],[new NameKey('Orlando','Keleshian'),'Engineer']]);
const optionalLastKeyOfResult = hashmap.optionalLastKeyOf('Engineer');
// getResult ~ Option.some(NameKey('Orlando','Keleshian'))

Advanced: using a custom equals, to get the last key in the hashmap

const myEquals = {equals: () => true}
const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const optionalLastKeyOfResult = hashmap.optionalLastKeyOf(0, myEquals);
// optionalLastKeyOfResult === Option.some(3)
// 0 doesn't exist in the hashMap, but we are circumventing using the key entirely.

Get an optional value from the map. This is effectively a more efficent combination of calling has and get at the same time.

• return the first some(value) from the [key,value] pair that matches
• if no elements match, it returns none().
• it is legitimate for keys to be null or undefined, and if set, will still acknowledge it exists, against the key.

Maps typically index keys, and so is generally a fast operation.

What is the value for a key

const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const getResult = hashmap.optionalGet(1);
// getResult === Option.some('value1') {value:'value1',has:true}

What is the value for a key that isn't there

const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const getResult = hashmap.optionalGet(4);
// getResult === Option.none {has:false}

What is the value for a key with an undefined value

const hashmap = new HashMap([[1,'value1'],[2,undefined],[3,'value3']]);
const getResult = hashmap.optionalGet(2);
// getResult === Option.some(undefined) {value:undefined,has:true}

Advanced: using a predefined hashCode and equals on the key

class NameKey {
    constructor(firstName, secondName) {
        this.firstName = firstName;
        this.secondName = secondName;
    }
    hashCode() {
         return (Mootable.hash(firstName) * 31) +Mootable.hash(secondName);
    }
    equals(other) {
         return other && other instanceof NameKey && other.firstName === this.firstName && other.secondName === this.secondName;
    }
}
const hashmap = new HashMap([[new NameKey('John','Smith'),'Librarian'],[new NameKey('Orlando','Keleshian'),'Engineer']]);
const key = new NameKey('John','Smith');
const getResult = hashmap.optionalGet(key);
// getResult === Option.some('Librarian') {value:'Librarian',has:true}

Advanced: using a custom hash and equals, to get the first entry for a specific hash

const myHash = 3;
const hashEquals = {hash: myHash, equals: () => true}
const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const getResult = hashmap.optionalGet(0, hashEquals);
// getResult === Option.some('value3')  {value:'value3',has:true}
// the hash of the number 3 is actually also 3. all 32 bit integers have the same hash.
// 0 doesn't exist in the hashMap, but we are circumventing using the key entirely.

Find the first value in the map which passes the provided MatchesPredicate.

• return the first value from the [key,value] pair that matches
• if no elements match, it returns undefined.
• if no predicate is defined, will return the first value it finds.

Find a value

const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const findResult = hashmap.find((value) => value.startsWith('val'));
// findResult === 'value1'

Can't find a value

const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const findResult = hashmap.find((value) => value.startsWith('something'));
// findResult === undefined

Find the last value in the map which passes the provided MatchesPredicate.

• return the last value from the [key,value] pair that matches
• if no elements match, it returns undefined.
• if no predicate is defined, will return the last value it finds. (It does this by iterating over the hashmap in reverse, and returning the first

item that matches)

Find the last value

const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const findLastResult = hashmap.findLast((value) => value.startsWith('val'));
// findLastResult === 'value3'

Can't find a value

const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const findLastResult = hashmap.findLast((value) => value.startsWith('something'));
// findLastResult === undefined

Find the first value in the map which passes the provided MatchesPredicate.

• return the first value from the [key,value] pair that matches, wrapped in an Option
• if no elements match, it returns none.
• if no predicate is defined, will return the first value it finds.

Find a value

const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const optionalFindResult = hashmap.optionalFind((value) => value.startsWith('val'));
// optionalFindResult.value === 'value1'
// optionalFindResult.has === true

Can't find a value

const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const optionalFindResult = hashmap.optionalFind((value) => value.startsWith('something'));
// optionalFindResult.has === false

Find the last value in the map which passes the provided MatchesPredicate.

• return the last value from the [key,value] pair that matches, wrapped in an Option
• if no elements match, it returns none.
• if no predicate is defined, will return the last value it finds. (It does this by iterating over the hashmap in reverse, and returning the first

item that matches)

Find a value

const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const optionalFindLastResult = hashmap.optionalFindLast((value) => value.startsWith('val'));
// optionalFindLastResult.value === 'value3'
// optionalFindLastResult.has === true

Can't find a value

const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const optionalFindLastResult = hashmap.optionalFindLast((value) => value.startsWith('something'));
// optionalFindLastResult.has === false

Find the first key in the map which passes the provided MatchesPredicate.

• return the first key from the [key,value] pair that matches
• if no elements match, it returns undefined.
• if no predicate is defined, will return the first key it finds.

Find a key

const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const findKeyResult = hashmap.findKey((value) => value.startsWith('val'));
// findKeyResult === 1

Can't find a key

const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const findKeyResult = hashmap.findKey((value) => value.startsWith('something'));
// findKeyResult === undefined

Find the last key in the map which passes the provided MatchesPredicate.

• return the last key from the [key,value] pair that matches
• if no elements match, it returns undefined.
• if no predicate is defined, will return the last key it finds. (It does this by iterating over the hashmap in reverse, and returning the first

item that matches)

Find a key

const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const findLastKeyResult = hashmap.findLastKey((value) => value.startsWith('val'));
// findLastKeyResult === 3

Can't find a key

const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const findLastKeyResult = hashmap.findLastKey((value) => value.startsWith('something'));
// findLastKeyResult === undefined

Find the first key in the map which passes the provided MatchesPredicate.

• return the first key from the [key,value] pair that matches, wrapped in an Option
• if no elements match, it returns none.
• if no predicate is defined, will return the first key it finds.

Find a key

const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const optionalFindKeyResult = hashmap.optionalFindKey((value) => value.startsWith('val'));
// optionalFindKeyResult.value === 1
// optionalFindKeyResult.has === true

Can't find a key

const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const optionalFindKeyResult = hashmap.optionalFindKey((value) => value.startsWith('something'));
// optionalFindKeyResult.has === false

Find the last key in the map which passes the provided MatchesPredicate.

• return the last key from the [key,value] pair that matches, wrapped in an Option
• if no elements match, it returns none.
• if no predicate is defined, will return the last key it finds. (It does this by iterating over the hashmap in reverse, and returning the first

item that matches)

Find a key

const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const optionalFindLastKeyResult = hashmap.optionalFindLastKey(value) => value.startsWith('val'));
// optionalFindLastKeyResult.value === 3
// optionalFindLastKeyResult.has === true

Can't find a key

const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const optionalFindLastKeyResult = hashmap.optionalFindLastKey((value) => value.startsWith('something'));
// optionalFindLastKeyResult.has === false

Sets a value onto this map, using the key as its reference.

• If the key already exists, this will overwrite the value with the new value.
• If it doesn't exist it adds the new key value pair to the map.
• NB: Ordering in a HashMap is not defined by insertion order (much), but by hash value (mostly).

set a value

const hashmap = new HashMap();
hashmap.set(1,'value1');
const hasResult = hashmap.has(1);
// hasResult === true

overwrite a value

const hashmap = new HashMap([[1,'value1'],[2,'value2']]);
hashmap.set(2,'other');
const getResult = hashmap.get(2);
// getResult === 'other'

Advanced: using a predefined hashCode and equals on the key

class NameKey {
    constructor(firstName, secondName) {
        this.firstName = firstName;
        this.secondName = secondName;
    }
    hashCode() {
         return (Mootable.hash(firstName) * 31) +Mootable.hash(secondName);
    }
    equals(other) {
         return other && other instanceof NameKey && other.firstName === this.firstName && other.secondName === this.secondName;
    }
}
const hashmap = new HashMap();
hashmap.set(new NameKey('John','Smith'),'Librarian');
const hasResult = hashmap.has(new NameKey('John','Smith'));
// hasResult === true

Advanced: using a custom hash and equals, to set a value to a specific hash

const hashmap = new HashMap();
hashmap.set(1,'value1', {hash: 3});
const hasResult = hashmap.has(3, {equals: () => true} );
// hasResult === true
// the hash of the number 3 is actually also 3. all 32 bit integers have the same hash.
// 0 doesn't exist in the hashMap, but we are circumventing using the key entirely.

Given a key and a handler object, the emplace method will either remap an existing entry, insert a new entry from a mapping function, or both. emplace will return the updated or inserted value.

• Error: if the insert method does not exist, and it can't find the key.

insert into the map

const hashmap = new HashMap();
const handler = {
    update: () => {
        return 'update';
    },
    insert: (key, map) => {
        return 'insert';
    }
};
const ret = hashmap.emplace('key', handler)
// hashmap = [['key', 'insert']]
// ret === 'insert'

update the map

const hashmap = new HashMap([['key','value']]);
const handler = {
    update: () => {
        return 'update';
    },
    insert: (key, map) => {
        return 'insert';
    }
};
const ret = hashmap.emplace('key', handler)
// hashmap = [['key', 'update']]
// ret === 'update'

insert into the map if the key already exists without an update

const hashmap = new HashMap([['key','value']]);
const handler = {
    insert: (key, map) => {
        return 'insert';
    }
};
const ret = hashmap.emplace('key', handler)
// hashmap = [['key', 'value']]
// ret === 'value'

update into the map without an insert method (throws an error)

const hashmap = new HashMap([['key','value']]);
const handler = {
    update: (oldValue, key, map) => {
        return 'update';
    }
};
hashmap.emplace('key', handler)
// throws an Error as insert doesn't exist
// hashmap = [['key', 'value']]

Advanced: using a predefined hashCode and equals on the key

class NameKey {
    constructor(firstName, secondName) {
        this.firstName = firstName;
        this.secondName = secondName;
    }
    hashCode() {
         return (Mootable.hash(firstName) * 31) +Mootable.hash(secondName);
    }
    equals(other) {
         return other && other instanceof NameKey && other.firstName === this.firstName && other.secondName === this.secondName;
    }
}
const handler = {
    insert: (key, map) => {
        return 'Librarian';
    }
};
const hashmap = new HashMap();
const ret = hashmap.emplace(new NameKey('John','Smith'),handler);
// ret === 'Librarian'

Advanced: using a custom hash and equals, to emplace a value to a specific hash

const handler = {
    insert: (key, map) => {
        return 'value1';
    }
};
const hashmap = new HashMap();
const ret = hashmap.emplace(1,handler, {hash: 3});
// ret === 'value1'
// the hash of the number 3 is actually also 3. all 32 bit integers have the same hash.
// 0 doesn't exist in the hashMap, but we are circumventing using the key entirely.

Copies all the entries from the map, array or iterable, into this hashmap.

• TypeError: if the provided object other is null or not iterable.

copy into the HashMap from an array of key value pairs

const hashmap = new HashMap([['key0','value0']]);
const arr = [[1,'value1'],[2,'value2'],[3,'value3']];
hashmap.copy(arr);
// hashmap.size === 4;

copy into the HashMap from another map

const hashmap = new HashMap([['key0','value0']]);
const map = new Map([[1,'value1'],[2,'value2'],[3,'value3']])
hashmap.copy(map);
// hashmap.size === 4;

copy into the HashMap from another HashMap

const first = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']])
const hashmap = new HashMap(first);
// hashmap.size === 3;

copy into the HashMap from a class with symbol iterator

const hashmap = new HashMap([['key0','value0']]);
class MyIterable = {
    *[Symbol.iterator] () {
        yield ["key1", "value1"];
        yield ["key2", "value2"];
        yield ["key3", "value3"];
        yield ["key4", "value4"];
    }
}
const iterable = new MyIterable();
hashmap.copy(iterable);
// hashmap.size === 5;
// it doesn't have to be a generator, an iterator works too.

copy into the HashMap from an object with an entries generator function

const hashmap = new HashMap([['key0','value0']]);
const entriesObj = {
    entries: function* () {
        yield ["key1", "value1"];
        yield ["key2", "value2"];
        yield ["key3", "value3"];
        yield ["key4", "value4"];
    }
}
hashmap.copy(entriesObj);
// hashmap.size === 5;
// it doesn't have to be a generator, an iterator works too.

copy into the HashMap from an object with a forEach function

const hashmap = new HashMap([['key0','value0']]);
const forEachObj = {
     forEach: (callback, ctx) => {
             for (let i = 1; i <= 4; i++) {
                 callback.call(ctx, 'value' + i, 'key' + i);
             }
     }
};
hashmap.copy(forEachObj);
// hashmap.size === 5;

Makes a full copy of this hashmap and returns the clone.

Deletes an entry from this hashmap, using the provided key

Clears the data from this hashmap. All data is orphaned, and will be Garbage Collected.

Execute the provided callback on every [key,value] pair of this map iterable.

Log all the keys and values.

const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
mapIterable.forEach((value) => console.log(key, value));
// will log to the console:
// 1 value1
// 2 value2
// 3 value3
// Ordering is deterministic on paper, but from a usability point of view effectively random
// as it is ordered by a mix of the hash of the key, and order of insertion.

Execute the provided callback on every [key,value] pair of this map iterable in reverse.

Log all the keys and values.

const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
mapIterable.forEachRight((value) => console.log(key, value));
// will log to the console:
// 3 value3
// 2 value2
// 1 value1
// Ordering is deterministic on paper, but from a usability point of view effectively random
// as it is ordered by a mix of the hash of the key, and order of insertion.

Test to see if ALL elements pass the test implemented by the passed MatchesPredicate.

• if any element does not match, returns false
• if all elements match, returns true.
• if no elements match, returns false.
• if the iterable is empty, returns true. (irrespective of the predicate)
• if no predicate is provided, returns true.

Do all values start with 'value'. (yes)

const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const everyResult = hashmap.every((value) => value.startsWith('value'));
// everyResult === true

Do all values start with value. (no)

const hashmap = new HashMap([[1,'value1'],[2,'doesntStart'],[3,'value3']]);
const everyResult = hashmap.every((value) => value.startsWith('value'));
// everyResult === false

Test to see if ANY element pass the test implemented by the passed MatchesPredicate.

• if any element matches, returns true.
• if all elements match returns true.
• if no elements match returns false.
• if the iterable is empty, returns true.
• if no predicate is provided, returns true.

Do any values start with value. (yes all of them)

const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const someResult = hashmap.some((value) => value.startsWith('value'));
// someResult === true

Do any values start with value. (yes 2 of them)

const hashmap = new HashMap([[1,'value1'],[2,'doesntStart'],[3,'value3']]);
const someResult = hashmap.some((value) => value.startsWith('value'));
// someResult === true

Iterate through the map reducing it to a single value.

add all the keys

const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const reduceResult = hashmap.reduce((accumulator, value, key) => accumulator+key, 0);
// reduceResult === 6

add all the values into one string in reverse order

const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const reduceResult = hashmap.reduce((accumulator, value) => value+accumulator, '');
// reduceResult === 'value3value2value1'

Iterate backwards through the map reducing it to a single value.

add all the keys

const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const reduceResult = hashmap.reduceRight((accumulator, value, key) => accumulator+key, 0);
// reduceResult === 6

add all the values into one string in reverse order

const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
const reduceResult = hashmap.reduceRight((accumulator, value) => value+accumulator, '');
// reduceResult === 'value1value2value3'

Iterates over all the entries in the map.

iterate over the map

const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
for ([key, value] of hashmap) {
    console.log(key,value);
}
// logs:
// 1 value1
// 2 value2
// 3 value3

Iterates over all the entries in the map.

iterate over the map

const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
for ([key, value] of hashmap.entries()) {
    console.log(key,value);
}
// logs:
// 1 value1
// 2 value2
// 3 value3

Iterates over all the entries in the map in reverse.

iterate over the map in reverse

const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
for ([key, value] of hashmap.entriesRight()) {
    console.log(key,value);
}
// logs:
// 3 value3
// 2 value2
// 1 value1

Iterates over all the keys in the map.

iterate over the keys

const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
for (const key of hashmap.keys()) {
    console.log(key);
}
// logs:
// 1
// 2
// 3

Iterates over all the values in the map.

iterate over the values

const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
for (const value of hashmap.values()) {
    console.log(value);
}
// logs:
// value1
// value2
// value3

Iterates over all the keys in the map in reverse.

iterate over the keys

const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
for (const key of hashmap.keysRight()) {
    console.log(key);
}
// logs:
// 3
// 2
// 1

Iterates over all the values in the map in reverse.

iterate over the values

const hashmap = new HashMap([[1,'value1'],[2,'value2'],[3,'value3']]);
for (const value of hashmap.valuesRight()) {
    console.log(value);
}
// logs:
// value3
// value2
// value1

Makes a copy of this LinkedHashMap

Iterates over all the entries in the map.

Iterates over all the entries in the map.

Iterates over all the entries in the map in reverse order.

Iterates over all the keys in the map.

Iterates over all the values in the map.

Iterates over all the keys in the map in reverse.

Iterates over all the values in the map in reverse.

A constant representation of an Option with nothing in it: {value:undefined,has:false}

Type: Option

create an option using none

const option = Option.none;
// option.has === false
// option.value === undefined
// option.size === 0

When called with a value returns an Option object of the form: {value:value,has:true} Even if a value is not provided it still counts as existing, this is different from other libraries, we are effectively saying, null and undefined count as valid values.

create an option using some

const myValue = 'hello';
const option = Option.some(myValue);
// option.has === true
// option.value === 'hello'
// option.size === 1

Return the size of this option.

• 1 if it has a value
• 0 if it doesn't

Provides an iterable for the Option If using a for loop.

• If it has a value the loop will execute just once.
• If it doesn't have a value the loop will not execute

iterating over some

const opt = Option.some("hello");
for (value of opt) {
   // loops once.
   console.log(opt);
}
console.log("world");
// logs - hello\nworld

iterating over none

const opt = Option.none;
for (value of opt) {
  // does not loop.
   console.log(opt);
}
console.log("world");
// logs - world