Collection

.clone()

→ Collection<K, V>

client.users.clone();

.concat(collections)

collections: ReadonlyCollection<K, V>[] → Collection<K, V>

client.users.concat(collections);

.each(fn)

fn: (value: V, key: K, collection: this) => void → this

Iterate without allocating; returns this for chaining.

client.users.each(fn);

.every(fn)

fn: (value: V, key: K) => boolean → boolean

client.users.every(fn);

.filter(fn)

fn: (value: V, key: K) => boolean → Collection<K, V>

client.users.filter(fn);

.find(fn)

fn: (value: V, key: K) => boolean → V | undefined

client.users.find(fn);

.findKey(fn)

fn: (value: V, key: K) => boolean → K | undefined

client.users.findKey(fn);

.first()

→ V | undefined

amount: number → V[]

First value, or the first amount values.

client.users.first();

.last()

→ V | undefined

amount: number → V[]

Last value, or the last amount values (no full-array alloc for a single item).

client.users.last();

.map(fn)

fn: (value: V, key: K) => T → T[]

client.users.map(fn);

.partition(fn)

fn: (value: V, key: K) => boolean → [Collection<K, V>, Collection<K, V>]

client.users.partition(fn);

.random()

→ V | undefined

amount: number → V[]

One random value, or amount unique random values.

client.users.random();

.reduce(fn, initialValue)

fn: (acc: T, value: V, key: K) => T, initialValue: T → T

client.users.reduce(fn, initialValue);

.some(fn)

fn: (value: V, key: K) => boolean → boolean

client.users.some(fn);

.sort(compareFn?)

compareFn?: (a: V, b: V, aKey: K, bKey: K) => number → this

client.users.sort();

.tap(fn)

fn: (collection: this) => void → this

client.users.tap(fn);

.toString()

→ string

client.users.toString();