@unikue/ts-multi-map
    Preparing search index...

    Class ReadonlyMultiValueMap<K, V>

    Readonly map with entries that contains a single key and multiple values

    David Hsing

    Type Parameters

    • K
    • V

    Implements

    • Omit<
          ReadonlyMap<K, V[]>,
          "forEach" | "get" | "has" | "entries" | "keys" | "values",
      >
    Index

    Constructors

    constructor

    Accessors

    [toStringTag] size

    Methods

    [iterator] entries forEach forEachBreakable forEachIndexing get getKey hasAllKeys hasAllValues hasAnyKeys hasAnyValues hasKey hasKeyValue hasValue isEmpty isNotEmpty keys toString values of

    Constructors

    Accessors

    • get "[toStringTag]"(): string

      Returns the string representation of the map identifier ('ReadonlyMultiValueMap')

      Returns string

      the string representation of the map identifier

    • get size(): number

      Returns the size of map

      Returns number

      the size of map

    Methods

    • Response for returning the list of key/values to iterate

      Returns IterableIterator<[K, V[]]>

      for (const [key, values] of map) {
          console.log(key);
      }

    • Returns the key/values entries of the map

      Returns [K, V[]][]

      the key/values entries of the map

    • Processes each entry in the map

      Parameters

      • callback: (values?: V[], key?: K) => void

        a callback function that processes each entry

      • OptionalthisArg: any

        any instance to retrieve 'this' reference in the callback function

      Returns void

      map.forEach((values, key) => {
          console.log(key);
      });

    • 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

      • OptionalthisArg: any

        any instance to retrieve 'this' reference in the callback function

      Returns void

      map.forEachBreakable((values, key) => {
          return true;
      });

    • 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

      • OptionalthisArg: any

        any instance to retrieve 'this' reference in the callback function

      Returns void

      map.forEachIndexing((values, key, index) => {
          console.log(index);
      });

    • 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

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

    • Returns the key with the given values

      Parameters

      • values: V[]

        the values to inspect

      • Optionaldefaults: K

        the default key if nothing matches the given value

      Returns undefined | K

      the key with the given value

      map.getKey(['foo', 'bar']);

    • 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

      map.hasAllKeys(['color', 'position']);

    • 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

      map.hasAllValues([['red', 'green', 'blue'], ['top', 'right', 'bottom', 'left']]);

    • 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

      const map = ReadonlyMultiValueMap.of([
          ['color', ['red', 'green', 'blue']]
      ]);
      map.hasAnyKeys(['color', 'position']);    // true

    • 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

      const map = ReadonlyMultiValueMap.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

    • Returns whether the map contains the given key

      Parameters

      • key: K

        the key to check

      Returns boolean

      whether the map contains the given key

      map.hasKey('color');

    • 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

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

    • 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

      const map = ReadonlyMultiValueMap.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

    • Returns whether the map is empty

      Returns boolean

      whether the map is empty

    • Returns whether the map is not empty

      Returns boolean

      whether the map is not empty

    • Returns the keys of the map

      Returns K[]

      the keys of the map

    • Returns the string representation of the map elements

      Returns string

      the string representation of the map elements

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

    • Returns the values array of the map

      Returns V[][]

      the values array of the map

    Settings

    Member Visibility

    On This Page

    Constructors
    Accessors
    Methods