Class Collection<K, V>

A reusable storage concept which blends the functionality of an Array with the efficient key-based lookup of a Map. This concept is reused throughout Foundry VTT where a collection of uniquely identified elements is required.

Type Parameters

  • K
  • V

Hierarchy (View Summary)

Accessors

contents

Methods

[iterator] filter find forEach get getName map reduce some toJSON

Accessors

contents

  • get contents(): V[]

    Return an Array of all the entry values in the Collection

    Returns V[]

Methods

[iterator]

  • "[iterator]"(): MapIterator<V>

    Then iterating over a Collection, we should iterate over its values instead of over its entries

    Returns MapIterator<V>

filter

  • filter(
        condition: (
            value: V,
            index: number,
            collection: Collection<K, V>,
        ) => unknown,
    ): V[]

    Filter the Collection, returning an Array of entries which match a functional condition.

    Parameters

    • condition: (value: V, index: number, collection: Collection<K, V>) => unknown

      The functional condition to test.

    Returns V[]

    An Array of matched values

    See

    Example: Filter the Collection for specific entries

    let c = new Collection([["a", "AA"], ["b", "AB"], ["c", "CC"]]);
    let hasA = c.filters(entry => entry.slice(0) === "A");

find

  • find(
        condition: (
            value: V,
            index: number,
            collection: Collection<K, V>,
        ) => unknown,
    ): undefined | V

    Find an entry in the Map using a functional condition.

    Parameters

    • condition: (value: V, index: number, collection: Collection<K, V>) => unknown

      The functional condition to test.

    Returns undefined | V

    The value, if found, otherwise undefined

    See

    Example: Create a new Collection and reference its contents

    let c = new Collection([["a", "A"], ["b", "B"], ["c", "C"]]);
    c.get("a") === c.find(entry => entry === "A"); // true

forEach

  • forEach(fn: (value: V) => void): void

    Apply a function to each element of the collection

    Parameters

    • fn: (value: V) => void

      A function to apply to each element

    Returns void

    See

    Array#forEach

    Example: Apply a function to each value in the collection

    let c = new Collection([["a", {active: false}], ["b", {active: false}], ["c", {active: false}]]);
    c.forEach(e => e.active = true);

get

  • get(key: string, options?: { strict?: boolean }): undefined | V

    Get an element from the Collection by its key.

    Parameters

    • key: string

      The key of the entry to retrieve

    • Optionaloptions: { strict?: boolean } = {}

      Additional options that affect how entries are retrieved

      • Optionalstrict?: boolean

        Throw an Error if the requested key does not exist. Default false.

    Returns undefined | V

    The retrieved entry value, if the key exists, otherwise undefined

    Example: Get an element from the Collection by key

    let c = new Collection([["a", "Alfred"], ["b", "Bob"], ["c", "Cynthia"]]);
    c.get("a"); // "Alfred"
    c.get("d"); // undefined
    c.get("d", {strict: true}); // throws Error

getName

  • getName(name: string, options?: { strict?: boolean }): undefined | V

    Get an entry from the Collection by name. Use of this method assumes that the objects stored in the collection have a "name" attribute.

    Parameters

    • name: string

      The name of the entry to retrieve

    • Optionaloptions: { strict?: boolean } = {}

      Additional options that affect how entries are retrieved

      • Optionalstrict?: boolean

        Throw an Error if the requested name does not exist. Default false.

    Returns undefined | V

    The retrieved entry value, if one was found, otherwise undefined

    Example: Get an element from the Collection by name (if applicable)

    let c = new Collection([["a", "Alfred"], ["b", "Bob"], ["c", "Cynthia"]]);
    c.getName("Alfred"); // "Alfred"
    c.getName("D"); // undefined
    c.getName("D", {strict: true}); // throws Error

map

  • map(transformer: (arg0: V, arg1: number, arg2: Collection) => any): any[]

    Transform each element of the Collection into a new form, returning an Array of transformed values

    Parameters

    • transformer: (arg0: V, arg1: number, arg2: Collection) => any

      A transformation function applied to each entry value. Positional arguments are the value, the index of iteration, and the collection being mapped.

    Returns any[]

    An Array of transformed values

reduce

  • reduce(
        reducer: (arg0: any, arg1: V, arg2: number, arg3: Collection) => any,
        initial: any,
    ): any

    Reduce the Collection by applying an evaluator function and accumulating entries

    Parameters

    • reducer: (arg0: any, arg1: V, arg2: number, arg3: Collection) => any

      A reducer function applied to each entry value. Positional arguments are the accumulator, the value, the index of iteration, and the collection being reduced.

    • initial: any

      An initial value which accumulates with each iteration

    Returns any

    The accumulated result

    See

    Example: Reduce a collection to an array of transformed values

    let c = new Collection([["a", "A"], ["b", "B"], ["c", "C"]]);
    let letters = c.reduce((s, l) => {
      return s + l;
    }, ""); // "ABC"

some

  • some(condition: (arg0: V, arg1: number, arg2: Collection) => boolean): boolean

    Test whether a condition is met by some entry in the Collection.

    Parameters

    • condition: (arg0: V, arg1: number, arg2: Collection) => boolean

      The functional condition to test. Positional arguments are the value, the index of iteration, and the collection being tested.

    Returns boolean

    Was the test condition passed by at least one entry?

    See

toJSON

  • toJSON(): object[]

    Convert the Collection to a primitive array of its contents.

    Returns object[]

    An array of contained values

Settings

Member Visibility

On This Page

Accessors
Methods