Class MultiValueMap<K, V>

Map with entries that contains a single key and multiple values

Author

David Hsing

Type Parameters

Implements

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

Constructors

constructor

new MultiValueMap<K, V>(entries?): MultiValueMap<K, V>
Construct a multi value map instance
Type Parameters
- K
- V
Parameters
- Optionalentries: MultiValueMapEntries<K, V>
  the map entries that represented as [K, V[]][]
Returns MultiValueMap<K, V>
Example
```
const map = new MultiValueMap([
    ['color', ['red', 'green', 'blue']]
]);
```

Accessors

[toStringTag]

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

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 key/values to iterate

Returns IterableIterator<[K, V[]], any, any>
Example
```
for (const [key, values] of map) {
    console.log(key);
}
```
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('color');
```

deleteByKeys

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

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('red');
```

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(['green', 'blue']);
```

deleteValueOfKey

deleteValueOfKey(key, value): boolean
Deletes a value for the given key from the map, keeping other values
Parameters
- key: K
  the key to operate
- value: V
  the value to delete
Returns boolean
whether the value has been removed
Example
```
map.deleteValueOfKey('color', 'blue');
```

entries

entries(): [K, V[]][]
Returns the key/values entries of the map

Returns [K, V[]][]
the key/values entries of the map

forEach

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

forEachBreakable

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

forEachIndexing

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

get

get(key, defaults?): undefined | V[]

Returns the values of the given key

Parameters

key: K
the key to retrieve
Optionaldefaults: V[]
the default values if not found

Returns undefined | V[]

the values of the given key

Example

const map = MultiValueMap.of([
    ['color', ['red', 'green', 'blue']]
]);
map.get('color');    // ['red', 'green', 'blue']
map.get('foobar', ['foo', 'bar']);    // ['foo', 'bar']

hasAllKeys

hasAllKeys(keys): boolean
Returns whether the map contains all the given keys
Parameters
- keys: K[]
  the keys to check
Returns boolean
whether the map contains all the given keys
Example
```
map.hasAllKeys('color', 'position');
```

hasAllValues

hasAllValues(values, exact?): boolean
Returns whether the map contains all the given values
Parameters
- values: V[][]
  the values to check
- exact: boolean = true
  whether matching entry values exactly
Returns boolean
whether the map contains all the given values
Example
```
map.hasAllValues(['red', 'green', 'blue'], ['top', 'right', 'bottom', 'left']);
```

hasAnyKeys

hasAnyKeys(keys): boolean
Returns whether the map contains any of the given keys
Parameters
- keys: K[]
  the keys to check
Returns boolean
whether the map contains any of the given keys
Example
```
const map = MultiValueMap.of([
    ['color', ['red', 'green', 'blue']]
]);
map.hasAnyKeys(['color', 'position']);    // true
```

hasAnyValues

hasAnyValues(values, exact?): boolean

Returns whether the map contains any of the given values

Parameters

values: V[][]
the values to check
exact: boolean = true
whether matching entry values exactly

Returns boolean

whether the map contains any of the given values

Example

const map = MultiValueMap.of([
    ['color', ['red', 'green', 'blue']],
    ['position', ['top', 'right', 'bottom', 'left']]
]);
map.hasAnyValues([['red', 'black'], ['green', 'blue']]);    // false
map.hasAnyValues([['top', 'right'], ['top', 'right', 'bottom', 'left']]);    // true

hasKey

hasKey(key): boolean
Returns whether the map contains the given key
Parameters
- key: K
  the key to check
Returns boolean
whether the map contains the given key
Example
```
map.hasKey('color');
```

hasKeyValue

hasKeyValue(key, value): boolean

Returns whether the map contains the given key/value pair

Parameters

key: K
the key to check
value: V
the value to check

Returns boolean

whether the map contains the given key/value pair

Example

const map = MultiValueMap.of([
    ['color', ['red', 'green', 'blue']]
]);
map.hasKeyValue('color', 'red');    // true
map.hasKeyValue('color', 'black');    // false

hasValue

hasValue(values, exact?): boolean

Returns whether any entries of the map that contains the given values

Parameters

values: V[]
the values to check
exact: boolean = true
whether matching entry values exactly

Returns boolean

whether any entries of the map that contains the given values

Example

const map = MultiValueMap.of([
    ['color', ['red', 'green', 'blue']],
    ['position', ['top', 'right', 'bottom', 'left']]
]);
map.hasValue(['red', 'black'], true);    // false
map.hasValue(['top', 'right'], true);    // false
map.hasValue(['top', 'right'], false);    // true

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 of the map

Returns K[]
the keys of the map

push

push(key, values): void
Push values onto the given key, the values will be appended to the given key
Parameters
- key: K
  the key to operate
- values: V[]
  the values to push
Returns void
Example
```
map.push('color', ['yellow', 'black']);
```

set

set(key, values): void
Sets the values of the given key
Parameters
- key: K
  the key to set
- values: V[]
  the values to set
Returns void
Example
```
map.set('color', ['red', 'green', 'blue']);
```

toString

toString(): string

Returns the string representation of the map elements

Returns string

the string representation of the map elements

Example

const map = MultiValueMap.of([
    ['color', ['red', 'green', 'blue']],
    ['position', ['top', 'right', 'bottom', 'left']]
]);
console.log(map.toString());    // 'color:[red,green,blue];position:[top,right,bottom,left]'

values

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

Returns V[][]
the values array of the map

`Static`of

of<K, V>(entries?): MultiValueMap<K, V>
Construct a multi value map instance
Type Parameters
- K
- V
Parameters
- Optionalentries: MultiValueMapEntries<K, V>
  the map entries that represented as [K, V[]][]
Returns MultiValueMap<K, V>
a multi value map instance
Example
```
const map = MultiValueMap.of([
    ['color', ['red', 'green', 'blue']]
]);
```

Class MultiValueMap<K, V>

Author

Type Parameters

Implements

Index

Constructors

Accessors

Methods

Constructors

constructor

Type Parameters

Parameters

Returns MultiValueMap<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

deleteValueOfKey

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

`Static`of