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?: MultiKeyMapEntries<K, V>): 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]>
Response for returning the list of keys/value to iterate

Returns IterableIterator<[K[], V]>
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: K[]): 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: K[][]): 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: V): 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: V[]): 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: (value?: V, keys?: K[]) => void, thisArg?: any): void
Processes each entry in the map
Parameters
- callback: (value?: V, keys?: K[]) => void
  a callback function that processes each entry
- 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: (value?: V, keys?: K[]) => boolean,
thisArg?: any,
): 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
- OptionalthisArg: any
  any instance to retrieve 'this' reference in the callback function
Returns void
Example
```
map.forEachBreakable((value, keys) => {
    return true;
});
```

forEachIndexing

forEachIndexing(
callback: (value?: V, keys?: K[], index?: number) => void,
thisArg?: any,
): 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
- 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: K[], defaults?: V): 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'
```

getKey

getKey(value: V, defaults?: K[]): undefined | K[]
Returns the keys with the given value
Parameters
- value: V
  the value to inspect
- Optionaldefaults: K[]
  the default keys if nothing matches the given value
Returns undefined | K[]
the keys with the given value
Example
```
map.getKey('bar');
```

hasAllKeys

hasAllKeys(keys: K[][], exact?: boolean): 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: V[]): 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: K[][], exact?: boolean): 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: V[]): 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: K[], exact?: boolean): 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: K[], value: V): 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: V): 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: K[], value: V): 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?: MultiKeyMapEntries<K, V>): 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]>

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

Returns void

Example

forEachBreakable

Parameters

Returns void

Example

forEachIndexing

Parameters

Returns void

Example

get

Parameters

Returns undefined | V

Example

getKey

Parameters

Returns undefined | K[]

Example

hasAllKeys

Parameters

Returns boolean

Example

hasAllValues

Parameters

Returns boolean

Example

hasAnyKeys

Parameters

Returns boolean

Example

hasAnyValues

Parameters

Returns boolean

Example

hasKey

`Static`of