Class MultiKeyMap<K, V>

Map with entries that contains multiple keys and a single value

Author

David Hsing

Type Parameters

Implements

Omit<Map<K[], V>,
    | "delete"
    | "forEach"
    | "get"
    | "has"
    | "set"
    | "entries"
    | "keys"
    | "values"
    | "push">

Index

Constructors

constructor

new MultiKeyMap<K, V>(entries?): MultiKeyMap<K, V>
Construct a multi key map instance
Type Parameters
- K
- V
Parameters
- Optionalentries: MultiKeyMapEntries<K, V>
  the map entries that represented as [K[], V][]
Returns MultiKeyMap<K, V>
Example
```
const map = new MultiKeyMap([
    [['row1', 'col1'], 'foo']
]);
```

Accessors

[toStringTag]

get [toStringTag](): string
Returns the string representation of the map identifier ('MultiKeyMap')

Returns string
the string representation of the map identifier

Implementation of Omit.[toStringTag]

size

get size(): number
Returns the size of map

Returns number
the size of map

Implementation of Omit.size

Methods

[iterator]

[iterator](): IterableIterator<[K[], V], any, any>
Response for returning the list of keys/value to iterate

Returns IterableIterator<[K[], V], any, any>
Example
```
for (const [keys, value] of map) {
    console.log(value);
}
```
Implementation of Omit.[iterator]

clear

clear(): void
Clears the map

Returns void
Implementation of Omit.clear

deleteByKey

deleteByKey(key): boolean
Deletes the entry with the given key
Parameters
- key: K[]
  the key to delete
Returns boolean
whether the entry has been deleted
Example
```
map.deleteByKey(['row1', 'col1']);
```

deleteByKeys

deleteByKeys(keys): boolean
Deletes all the entries with the given keys
Parameters
- keys: K[][]
  the keys to delete
Returns boolean
whether any of the entries has been deleted
Example
```
map.deleteByKey([['row1', 'col1'], ['row2', 'col2']]);
```

deleteByValue

deleteByValue(value): boolean
Deletes the entry/entries with the given value
Parameters
- value: V
  the value to delete
Returns boolean
whether the entry/entries has been deleted
Example
```
map.deleteByValue('foo');
```

deleteByValues

deleteByValues(values): boolean
Deletes all the entries with any of the given values
Parameters
- values: V[]
  the values to delete
Returns boolean
whether any of the entries has been deleted
Example
```
map.deleteByValues(['foo', 'bar']);
```

entries

entries(): [K[], V][]
Returns the keys/value entries of the map

Returns [K[], V][]
the keys/value entries of the map

forEach

forEach(callback, thisArg?): void
Processes each entry in the map
Parameters
- callback: ((value: V, keys: K[]) => void)
  a callback function that processes each entry
  - - (value, keys): void
    - Parameters
      value: V
      keys: K[]
      Returns void
- OptionalthisArg: any
  any instance to retrieve 'this' reference in the callback function
Returns void
Example
```
map.forEach((value, keys) => {
    console.log(value);
});
```

forEachBreakable

forEachBreakable(callback, thisArg?): void
Processes each entry in the map with breakable capability
Parameters
- callback: ((value: V, keys: K[]) => boolean)
  a callback function that processes each entry. Returning false indicates to break the map iteration
  - - (value, keys): boolean
    - Parameters
      value: V
      keys: K[]
      Returns boolean
- OptionalthisArg: any
  any instance to retrieve 'this' reference in the callback function
Returns void
Example
```
map.forEachBreakable((value, keys) => {
    return true;
});
```

forEachIndexing

forEachIndexing(callback, thisArg?): void
Processes each entry in the map with index capability
Parameters
- callback: ((value: V, keys: K[], index: number) => void)
  a callback function that processes each entry
  - - (value, keys, index): void
    - Parameters
      value: V
      keys: K[]
      index: number
      Returns void
- OptionalthisArg: any
  any instance to retrieve 'this' reference in the callback function
Returns void
Example
```
map.forEachIndexing((value, keys, index) => {
    console.log(index);
});
```

get

get(keys, defaults?): undefined | V
Returns the value of the given keys
Parameters
- keys: K[]
  the keys to retrieve
- Optionaldefaults: V
  the default value if not found
Returns undefined | V
the value of the given keys
Example
```
const map = MultiKeyMap.of([
    [['row1', 'col1'], 'foo']
]);
map.get(['row1', 'col1']);    // 'foo'
map.get(['row2', 'col2'], 'bar');    // 'bar'
```

hasAllKeys

hasAllKeys(keys, exact?): boolean
Returns whether the map contains all the given keys
Parameters
- keys: K[][]
  the keys to check
- exact: boolean = true
  whether matching entry values exactly
Returns boolean
whether the map contains all the given keys
Example
```
const map = MultiKeyMap.of([
    [['row1', 'col1'], 'foo']
]);
map.hasAllKeys([['row1', 'col1'], ['row2', 'col2']]);    // false
```

hasAllValues

hasAllValues(values): boolean
Returns whether the map contains all the given values
Parameters
- values: V[]
  the values to check
Returns boolean
whether the map contains all the given values
Example
```
map.hasAllValues(['foo']);
```

hasAnyKeys

hasAnyKeys(keys, exact?): boolean
Returns whether the map contains any of the given keys
Parameters
- keys: K[][]
  the keys to check
- exact: boolean = true
  whether matching entry values exactly
Returns boolean
whether the map contains any of the given keys
Example
```
const map = MultiKeyMap.of([
    [['row1', 'col1'], 'foo']
]);
map.hasAnyKeys([['row1', 'col1'], ['row2', 'col2']]);    // true
```

hasAnyValues

hasAnyValues(values): boolean
Returns whether the map contains any of the given values
Parameters
- values: V[]
  the values to check
Returns boolean
whether the map contains any of the given values
Example
```
const map = MultiKeyMap.of([
    [['row1', 'col1'], 'foo']
]);
map.hasAnyValues(['foo', 'bar']);    // true
```

hasKey

hasKey(keys, exact?): boolean
Returns whether the map contains the given keys
Parameters
- keys: K[]
  the keys to check
- exact: boolean = true
  whether matching entry values exactly
Returns boolean
whether the map contains the given key
Example
```
map.hasKey(['row1', 'col1']);
```

hasKeyValue

hasKeyValue(keys, value): boolean

Returns whether the map contains the given keys/value pair

Parameters

keys: K[]
the keys to check
value: V
the value to check

Returns boolean

whether the map contains the given keys/value pair

Example

const map = MultiKeyMap.of([
    [['row1', 'col1'], 'foo']
]);
map.hasKeyValue(['row1', 'col1'], 'foo');    // true
map.hasKeyValue(['row1', 'col1'], 'bar');    // false

hasValue

hasValue(value): boolean

Returns whether the map contains the given value

Parameters

value: V
the value to check

Returns boolean

whether the map contains the given value

Example

const map = MultiKeyMap.of([
    [['row1', 'col1'], 'foo']
]);
map.hasValue('foo');    // true
map.hasValue('bar');    // false

isEmpty

isEmpty(): boolean
Returns whether the map is empty

Returns boolean
whether the map is empty

isNotEmpty

isNotEmpty(): boolean
Returns whether the map is not empty

Returns boolean
whether the map is not empty

keys

keys(): K[][]
Returns the keys array of the map

Returns K[][]
the keys array of the map

set

set(keys, value): void
Sets the value of the given keys
Parameters
- keys: K[]
  the keys to set
- value: V
  the value to set
Returns void
Example
```
map.set(['row1', 'col1'], 'bar');
```

toString

toString(): string

Returns the string representation of the map elements

Returns string

the string representation of the map elements

Example

const map = MultiKeyMap.of([
    [['row1', 'col1'], 'foo'],
    [['row2', 'col2'], 'bar']
]);
console.log(map.toString());    // '[row1,col1]:foo;[row2,col2]:bar'

values

values(): V[]
Returns the values of the map

Returns V[]
the values of the map

`Static`of

of<K, V>(entries?): MultiKeyMap<K, V>
Construct a multi key map instance
Type Parameters
- K
- V
Parameters
- Optionalentries: MultiKeyMapEntries<K, V>
  the map entries that represented as [K[], V][]
Returns MultiKeyMap<K, V>
a multi key map instance
Example
```
const map = MultiKeyMap.of([
    [['row1', 'col1'], 'foo']
]);
```

Class MultiKeyMap<K, V>

Author

Type Parameters

Implements

Index

Constructors

Accessors

Methods

Constructors

constructor

Type Parameters

Parameters

Returns MultiKeyMap<K, V>

Example

Accessors

[toStringTag]

Returns string

size

Returns number

Methods

[iterator]

Returns IterableIterator<[K[], V], any, any>

Example

clear

Returns void

deleteByKey

Parameters

Returns boolean

Example

deleteByKeys

Parameters

Returns boolean

Example

deleteByValue

Parameters

Returns boolean

Example

deleteByValues

Parameters

Returns boolean

Example

entries

Returns [K[], V][]

forEach

Parameters

Parameters

Returns void

Returns void

Example

forEachBreakable

Parameters

Parameters

Returns boolean

Returns void

Example

forEachIndexing

Parameters

Parameters

Returns void

Returns void

Example

get

Parameters

Returns undefined | V

Example

hasAllKeys

Parameters

Returns boolean

Example

hasAllValues

Parameters

Returns boolean

Example

hasAnyKeys

Parameters

Returns boolean

Example

hasAnyValues

Parameters

Returns boolean

`Static`of