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.

Template: K

Template: V

Type Parameters

K extends string
V

Hierarchy (View Summary)

Map
- Collection

Index

Accessors

contents

Methods

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

Accessors

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>
Overrides Map.[iterator]

every

every(
condition: (element: V, index: number, set: Collection<K, V>) => boolean,
): boolean
Test whether a condition is met by every entry in the Collection.
Parameters
- condition: (element: V, index: number, set: Collection<K, V>) => boolean
  The functional condition to test.
Returns boolean
True if the test condition was truthy for every entry.

See

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,
): V | undefined
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 V | undefined
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, index: number) => void): void
Apply a function to each element of the collection
Parameters
- fn: (value: V, index: number) => 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);
```
Overrides Map.forEach

get

get(key: string, options?: { strict?: boolean }): V | undefined
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 V | undefined
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
```
Overrides Map.get

getName

getName(name: string, options?: { strict?: boolean }): V | undefined
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 V | undefined
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<U>(
    transformer: (
        element: V,
        index: number,
        collection: Collection<K, V>,
    ) => U,
): U[]
Transform each element of the Collection into a new form, returning an Array of transformed values
Type Parameters
- U
Parameters
- transformer: (element: V, index: number, collection: Collection<K, V>) => U
  A transformation function applied to each entry value.
Returns U[]
An Array of transformed values

See

reduce

reduce<U>(
    reducer: (
        accum: U,
        element: T,
        index: number,
        collection: Collection<K, V>,
    ) => U,
    initial: U,
): U
Reduce the Collection by applying an evaluator function and accumulating entries
Type Parameters
- U
Parameters
- reducer: (accum: U, element: T, index: number, collection: Collection<K, V>) => U
  A reducer function applied to each entry value.
- initial: U
  An initial value which accumulates with each iteration
Returns U
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: (element: V, index: number, set: Collection<K, V>) => boolean,
): boolean
Test whether a condition is met by some entry in the Collection.
Parameters
- condition: (element: V, index: number, set: Collection<K, V>) => boolean
  The functional condition to test.
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

Class Collection<K, V>

Template: K

Template: V

Type Parameters

Hierarchy (View Summary)

Index

Accessors

Methods

Accessors

contents

Returns V[]

Methods

[iterator]

Returns MapIterator<V>

every

Parameters

Returns boolean

See

filter

Parameters

Returns V[]

See

Example: Filter the Collection for specific entries

find

Parameters

Returns V | undefined

See

Example: Create a new Collection and reference its contents

forEach

Parameters

Returns void

See

Example: Apply a function to each value in the collection

get

Parameters

Optionalstrict?: boolean

Returns V | undefined

Example: Get an element from the Collection by key

getName

Parameters

Optionalstrict?: boolean

Returns V | undefined

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

map

Type Parameters

Parameters

Returns U[]

See

reduce

Type Parameters

Parameters

Returns U

See

Example: Reduce a collection to an array of transformed values

some

Parameters

Returns boolean

See

toJSON

Returns object[]

Settings

On This Page

`Optional`strict?: boolean

`Optional`strict?: boolean