Collection.Keyed

Глубоко преобразует эту коллекцию Keyed в эквивалентный объект JavaScript.

toJS(): {[key: string]: DeepCopy<V>}

Преобразует ключи в строки.

Поверхностно преобразует эту коллекцию Keyed в эквивалентный объект JavaScript.

toJSON(): {[key: string]: V}

Преобразует ключи в строки.

Поверхностно преобразует эту коллекцию в массив.

toArray(): Array<[K, V]>

Поверхностно преобразует эту коллекцию в объект.

toObject(): {[key: string]: V}

Преобразует ключи в строки.

Возвращает Seq.Keyed.

toSeq(): Seq.Keyed<K, V>

Возвращает Seq.Keyed из этой коллекции, где индексы обрабатываются как ключи.

toKeyedSeq(): Seq.Keyed<K, V>

Это полезно, если вы хотите работать с Collection.Indexed и сохранить пары [индекс, значение].

Возвращаемый Seq будет иметь такой же порядок итерации, как и эта коллекция.

const { Seq } = require('immutable')
const indexedSeq = Seq([ 'A', 'B', 'C' ])
// Seq [ "A", "B", "C" ]
indexedSeq.filter(v => v === 'B')
// Seq [ "B" ]
const keyedSeq = indexedSeq.toKeyedSeq()
// Seq { 0: "A", 1: "B", 2: "C" }
keyedSeq.filter(v => v === 'B')
// Seq { 1: "B" }run it

Возвращает Seq.Indexed значений этой коллекции, игнорируя ключи.

toIndexedSeq(): Seq.Indexed<V>

Возвращает Seq.Set значений этой коллекции, игнорируя ключи.

toSetSeq(): Seq.Set<V>

Возвращает новую коллекцию Collection.Keyed того же типа, где ключи и значения поменялись местами.

flip(): Collection.Keyed<V, K>

const { Map } = require('immutable')
Map({ a: 'z', b: 'y' }).flip()
// Map { "z": "a", "y": "b" }run it

Возвращает новую коллекцию Collection.Keyed со значениями, прошедшими через функцию mapper.

map<M>(mapper: (value: V, key: K, iter: this) => M,context?: unknown): Collection.Keyed<K, M>

const { Collection } = require('immutable')
Collection.Keyed({ a: 1, b: 2 }).map(x => 10 * x)
// Seq { "a": 10, "b": 20 }

Примечание: map() всегда возвращает новую инстанцию, даже если на каждом шаге вышло то же значение.

Возвращает новую коллекцию Collection.Keyed того же типа с ключами, прошедшими через функцию mapper.

mapKeys<M>(mapper: (key: K, value: V, iter: this) => M,context?: unknown): Collection.Keyed<M, V>

const { Map } = require('immutable')
Map({ a: 1, b: 2 }).mapKeys(x => x.toUpperCase())
// Map { "A": 1, "B": 2 }run it

Примечание: mapKeys() всегда возвращает новую инстанцию, даже если на каждом шаге выходил один и тот же ключ.

Возвращает новую коллекцию Collection.Keyed того же типа с парами [ключ, значение] (кортежами), прошедшими через функцию mapper.

mapEntries<KM, VM>(mapper: (entry: [K, V], index: number, iter: this) => [KM, VM] | undefined,context?: unknown): Collection.Keyed<KM, VM>

const { Map } = require('immutable')
Map({ a: 1, b: 2 })
  .mapEntries(([ k, v ]) => [ k.toUpperCase(), v * 2 ])
// Map { "A": 2, "B": 4 }run it

Примечание: mapEntries() всегда возвращает новую инстанцию, даже если на каждом шаге получалась та же пара.

Если функция маппера возвращает undefined, то пара будет отфильтрована.

Плоская маппинг коллекции, возвращая коллекцию того же типа.

flatMap<KM, VM>(mapper: (value: V, key: K, iter: this) => Iterable<[KM, VM]>,context?: unknown): Collection.Keyed<KM, VM>

Аналогично collection.map(...).flatten(true).

Истина, если у этой и другой коллекции есть равенство значений, как определено в Immutable.is().

equals(other: unknown): boolean

Примечание: Это эквивалентно Immutable.is(this, other), но предоставлено для возможности цепочечных выражений.

Вычисляет и возвращает хэшированный идентификатор для этой коллекции.

hashCode(): number

Хэш-код коллекции используется для определения потенциального равенства и используется при добавлении этой коллекции в Set или в качестве ключа в Map, позволяя выполнять поиск по другой инстанции.

const a = List([ 1, 2, 3 ]);
const b = List([ 1, 2, 3 ]);
assert.notStrictEqual(a, b); // different instances
const set = Set([ a ]);
assert.equal(set.has(b), true);run it

Если у двух значений одинаковый хэш-код, они не гарантированно равны. Если у двух значений разные хэш-коды, они не равны.

Истина, если ключ существует в этой Collection, используя Immutable.is для определения равенства.

has(key: K): boolean

Истина, если значение существует в этой Collection, используя Immutable.is для определения равенства.

includes(value: V): boolean

В случае, если Collection не пуста, возвращает первый элемент Collection. В случае, если Collection пуста, возвращает необязательное значение по умолчанию, если оно предоставлено; в противном случае возвращает undefined.

first<NSV>(notSetValue?: NSV): V | NSV

В случае, если Collection не пуста, возвращает последний элемент Collection. В случае, если Collection пуста, возвращает необязательное значение по умолчанию, если оно предоставлено; в противном случае возвращает undefined.

last<NSV>(notSetValue?: NSV): V | NSV

Возвращает значение, найденное по пути ключей или индексов через вложенные коллекции.

getIn(searchKeyPath: Iterable<unknown>, notSetValue?: unknown): unknown

const { Map, List } = require('immutable')
const deepData = Map({ x: List([ Map({ y: 123 }) ]) });
deepData.getIn(['x', 0, 'y']) // 123run it

Простые объекты JavaScript или массивы могут быть вложены в коллекцию Immutable.js, и getIn() также может получить доступ к этим значениям:

const { Map, List } = require('immutable')
const deepData = Map({ x: [ { y: 123 } ] });
deepData.getIn(['x', 0, 'y']) // 123run it

Истина, если результат следования по пути ключей или индексов через вложенные коллекции приводит к установленному значению.

hasIn(searchKeyPath: Iterable<unknown>): boolean

Это может быть очень полезно как способ "прицепить" обычную функцию к последовательности методов. RxJS называет это "let", а lodash — "thru".

update<R>(updater: (value: this) => R): R

Например, чтобы просуммировать Seq после преобразования и фильтрации:

const { Seq } = require('immutable')

function sum(collection) {
  return collection.reduce((sum, x) => sum + x, 0)
}
Seq([ 1, 2, 3 ])
  .map(x => x + 1)
  .filter(x => x % 2 === 0)
  .update(sum)
// 6run it

Преобразует эту коллекцию в Map. Бросает исключение, если ключи не хэшируемы.

toMap(): Map<K, V>

Примечание: Это эквивалентно Map(this.toKeyedSeq()), но предоставлено для удобства и возможности цепочечных выражений.

Преобразует эту коллекцию в Map, сохраняя порядок итерации.

toOrderedMap(): OrderedMap<K, V>

Примечание: Это эквивалентно OrderedMap(this.toKeyedSeq()), но предоставлено для удобства и возможности цепочечных выражений.

Преобразует эту коллекцию в Set, игнорируя ключи. Бросает исключение, если значения не хэшируемы.

toSet(): Set<V>

Примечание: Это эквивалентно Set(this), но предоставлено для возможности цепочечных выражений.

Преобразует эту коллекцию в Set, сохраняя порядок итерации и игнорируя ключи.

toOrderedSet(): OrderedSet<V>

Примечание: Это эквивалентно OrderedSet(this.valueSeq()), но предоставлено для удобства и возможности цепочечных выражений.

Преобразует эту коллекцию в список, отбрасывая ключи.

toList(): List<V>

Это аналогично List(collection), но предоставлено для возможности цепочек выражений. Однако, при вызове на Map или других коллекциях с ключами, collection.toList() отбрасывает ключи и создаёт список только значений, тогда как List(collection) создаёт список кортежей записей.

const { Map, List } = require('immutable')
var myMap = Map({ a: 'Apple', b: 'Banana' })
List(myMap) // List [ [ "a", "Apple" ], [ "b", "Banana" ] ]
myMap.toList() // List [ "Apple", "Banana" ]run it

Преобразует эту коллекцию в стек, отбрасывая ключи. Бросает исключение, если значения не хешируемы.

toStack(): Stack<V>

Примечание: это эквивалентно Stack(this), но предоставлено для возможности цепочек выражений.

Итератор ключей этой Collection.

keys(): IterableIterator<K>

Примечание: это вернёт итератор ES6, который не поддерживает алгоритмы последовательностей Immutable.js. Используйте keySeq вместо этого, если это нужно.

Итератор значений этой Collection.

values(): IterableIterator<V>

Примечание: это вернёт итератор ES6, который не поддерживает алгоритмы последовательностей Immutable.js. Используйте valueSeq вместо этого, если это нужно.

Итератор записей этой Collection в виде кортежей [ key, value ].

entries(): IterableIterator<[K, V]>

Примечание: это вернёт итератор ES6, который не поддерживает алгоритмы последовательностей Immutable.js. Используйте entrySeq вместо этого, если это нужно.

Возвращает новый Seq.Indexed ключей этой коллекции, отбрасывая значения.

keySeq(): Seq.Indexed<K>

Возвращает Seq.Indexed значений этой коллекции, отбрасывая ключи.

valueSeq(): Seq.Indexed<V>

Возвращает новый Seq.Indexed кортежей [ключ, значение].

entrySeq(): Seq.Indexed<[K, V]>

Возвращает новую коллекцию того же типа, содержащую только записи, для которых функция predicate возвращает false.

filterNot(predicate: (value: V, key: K, iter: this) => boolean,context?: unknown): this

const { Map } = require('immutable')
Map({ a: 1, b: 2, c: 3, d: 4}).filterNot(x => x % 2 === 0)
// Map { "a": 1, "c": 3 }run it

Примечание: filterNot() всегда возвращает новый экземпляр, даже если не отфильтровывает никаких значений.

Возвращает новую коллекцию того же типа в обратном порядке.

reverse(): this

Возвращает новую коллекцию того же типа, содержащую те же записи, стабильно отсортированные с использованием comparator.

sort(comparator?: (valueA: V, valueB: V) => number): this

Если comparator не предоставлен, используется по умолчанию компаратор, который использует < и >.

comparator(valueA, valueB):

• Возвращает 0, если элементы не должны меняться местами.
• Возвращает -1 (или любое отрицательное число), если valueA идёт перед valueB.
• Возвращает 1 (или любое положительное число), если valueA идёт после valueB.
• Является чистой функцией, т.е. всегда должна возвращать то же значение для одной и той же пары значений.

При сортировке коллекций, у которых нет определённого порядка, будут возвращены их упорядоченные эквиваленты. Например, map.sort() возвращает OrderedMap.

const { Map } = require('immutable')
Map({ "c": 3, "a": 1, "b": 2 }).sort((a, b) => {
  if (a < b) { return -1; }
  if (a > b) { return 1; }
  if (a === b) { return 0; }
});
// OrderedMap { "a": 1, "b": 2, "c": 3 }run it

Примечание: sort() всегда возвращает новый экземпляр, даже если исходный уже был отсортирован.

Примечание: Это всегда операция с немедленным результатом.

Как и sort, но также принимает comparatorValueMapper, что позволяет сортировать более сложными способами:

sortBy<C>(comparatorValueMapper: (value: V, key: K, iter: this) => C,comparator?: (valueA: C, valueB: C) => number): this

const { Map } = require('immutable')
const beattles = Map({
  John: { name: "Lennon" },
  Paul: { name: "McCartney" },
  George: { name: "Harrison" },
  Ringo: { name: "Starr" },
});
beattles.sortBy(member => member.name);run it

Примечание: sortBy() всегда возвращает новый экземпляр, даже если исходный уже был отсортирован.

Примечание: Это всегда операция с немедленным результатом.

Возвращает Collection.Keyed из Collection.Keyeds, сгруппированных по результату выполнения функции grouper.

groupBy<G>(grouper: (value: V, key: K, iter: this) => G,context?: unknown): Seq.Keyed<G, Collection<K, V>>

Примечание: Это всегда операция с немедленным результатом.

const { List, Map } = require('immutable')
const listOfMaps = List([
  Map({ v: 0 }),
  Map({ v: 1 }),
  Map({ v: 1 }),
  Map({ v: 0 }),
  Map({ v: 2 })
])
const groupsOfMaps = listOfMaps.groupBy(x => x.get('v'))
// Map {
//   0: List [ Map{ "v": 0 }, Map { "v": 0 } ],
//   1: List [ Map{ "v": 1 }, Map { "v": 1 } ],
//   2: List [ Map{ "v": 2 } ],
// }run it

Функция sideEffect выполняется для каждой записи в коллекции.

forEach(sideEffect: (value: V, key: K, iter: this) => unknown,context?: unknown): number

В отличие от Array#forEach, если любой вызов sideEffect возвращает false, итерация остановится. Возвращает количество итерированных записей (включая последнюю итерацию, которая вернула false).

Возвращает новую коллекцию того же типа, представляющую часть этой коллекции от начала до, но не включая, конец.

slice(begin?: number, end?: number): this

Если begin отрицательное, оно отсчитывается от конца коллекции. Например, slice(-2) возвращает коллекцию из последних двух записей. Если не указано, новая коллекция начнётся с начала этой коллекции.

Если end отрицательное, оно отсчитывается от конца коллекции. Например, slice(0, -1) возвращает коллекцию всего, кроме последней записи. Если не указано, новая коллекция продолжится до конца этой коллекции.

Если запрашиваемый срез эквивалентен текущей коллекции, он вернёт её саму.

Возвращает новую коллекцию того же типа, содержащую все записи, кроме первой.

rest(): this

Возвращает новую коллекцию того же типа, содержащую все записи, кроме последней.

butLast(): this

Возвращает новую коллекцию того же типа, исключающую первые amount записи из этой коллекции.

skip(amount: number): this

Возвращает новую коллекцию того же типа, исключающую последние amount записи из этой коллекции.

skipLast(amount: number): this

Возвращает новую коллекцию того же типа, содержащую записи, начиная с момента, когда predicate впервые возвращает false.

skipWhile(predicate: (value: V, key: K, iter: this) => boolean,context?: unknown): this

const { List } = require('immutable')
List([ 'dog', 'frog', 'cat', 'hat', 'god' ])
  .skipWhile(x => x.match(/g/))
// List [ "cat", "hat", "god" ]run it

Возвращает новую коллекцию того же типа, содержащую записи, начиная с момента, когда predicate впервые возвращает true.

skipUntil(predicate: (value: V, key: K, iter: this) => boolean,context?: unknown): this

const { List } = require('immutable')
List([ 'dog', 'frog', 'cat', 'hat', 'god' ])
  .skipUntil(x => x.match(/hat/))
// List [ "hat", "god" ]run it

Возвращает новую коллекцию того же типа, содержащую первые amount записи из этой коллекции.

take(amount: number): this

Возвращает новую коллекцию того же типа, содержащую последние amount записи из этой коллекции.

takeLast(amount: number): this

Возвращает новую коллекцию того же типа, содержащую записи из этой коллекции, пока predicate возвращает true.

takeWhile(predicate: (value: V, key: K, iter: this) => boolean,context?: unknown): this

const { List } = require('immutable')
List([ 'dog', 'frog', 'cat', 'hat', 'god' ])
  .takeWhile(x => x.match(/o/))
// List [ "dog", "frog" ]run it

Возвращает новую коллекцию того же типа, содержащую записи из этой коллекции, пока predicate возвращает false.

takeUntil(predicate: (value: V, key: K, iter: this) => boolean,context?: unknown): this

const { List } = require('immutable')
List([ 'dog', 'frog', 'cat', 'hat', 'god' ])
  .takeUntil(x => x.match(/at/))
// List [ "dog", "frog" ]run it

True, если predicate возвращает true для всех записей в коллекции.

every(predicate: (value: V, key: K, iter: this) => boolean,context?: unknown): boolean

Истина, если predicate возвращает true для любого элемента в коллекции.

some(predicate: (value: V, key: K, iter: this) => boolean,context?: unknown): boolean

Объединяет значения в строку, вставляя разделитель между каждым. По умолчанию разделитель — ",".

join(separator?: string): string

Возвращает true, если эта коллекция не содержит значений.

isEmpty(): boolean

Для некоторых ленивых Seq, isEmpty может потребоваться итерирование для определения пустоты. Будет выполнено не более одной итерации.

Возвращает Seq.Keyed подсчетов, сгруппированных по возвращаемому значению функции grouper.

countBy<G>(grouper: (value: V, key: K, iter: this) => G,context?: unknown): Map<G, number>

Примечание: это не ленивая операция.

Возвращает первое значение, для которого predicate возвращает true.

find(predicate: (value: V, key: K, iter: this) => boolean,context?: unknown,notSetValue?: V): V | undefined

Возвращает последнее значение, для которого predicate возвращает true.

findLast(predicate: (value: V, key: K, iter: this) => boolean,context?: unknown,notSetValue?: V): V | undefined

Примечание: predicate будет вызываться для каждого элемента в обратном порядке.

Возвращает первую пару [ключ, значение], для которой predicate возвращает true.

findEntry(predicate: (value: V, key: K, iter: this) => boolean,context?: unknown,notSetValue?: V): [K, V] | undefined

Возвращает последнюю пару [ключ, значение], для которой predicate возвращает true.

findLastEntry(predicate: (value: V, key: K, iter: this) => boolean,context?: unknown,notSetValue?: V): [K, V] | undefined

Примечание: predicate будет вызываться для каждого элемента в обратном порядке.

Возвращает ключ, для которого predicate возвращает true.

findKey(predicate: (value: V, key: K, iter: this) => boolean,context?: unknown): K | undefined

Возвращает последний ключ, для которого predicate возвращает true.

findLastKey(predicate: (value: V, key: K, iter: this) => boolean,context?: unknown): K | undefined

Примечание: predicate будет вызываться для каждого элемента в обратном порядке.

Возвращает ключ, связанный со значением поиска, или undefined.

keyOf(searchValue: V): K | undefined

Возвращает последний ключ, связанный со значением поиска, или undefined.

lastKeyOf(searchValue: V): K | undefined

Возвращает максимальное значение в этой коллекции. Если некоторые значения сравнимы, будет возвращено первое найденное.

max(comparator?: (valueA: V, valueB: V) => number): V | undefined

comparator используется так же, как и Collection#sort. Если не указано, по умолчанию используется компаратор >.

Если два значения считаются эквивалентными, будет возвращено первое встретившееся. В противном случае max будет работать независимо от порядка ввода, если компаратор коммутативный. Компаратор по умолчанию > коммутативен только при отсутствии различий в типах.

Если comparator возвращает 0, и хотя бы одно значение — NaN, undefined или null, будет возвращено это значение.

Подобно max, но также принимает comparatorValueMapper, что позволяет сравнивать более сложными способами:

maxBy<C>(comparatorValueMapper: (value: V, key: K, iter: this) => C,comparator?: (valueA: C, valueB: C) => number): V | undefined

const { List, } = require('immutable');
const l = List([
  { name: 'Bob', avgHit: 1 },
  { name: 'Max', avgHit: 3 },
  { name: 'Lili', avgHit: 2 } ,
]);
l.maxBy(i => i.avgHit); // will output { name: 'Max', avgHit: 3 }run it

Возвращает минимальное значение в этой коллекции. Если некоторые значения сравнимы, будет возвращено первое найденное.

min(comparator?: (valueA: V, valueB: V) => number): V | undefined

comparator используется так же, как и Collection#sort. Если не указано, по умолчанию используется компаратор <.

Если два значения считаются эквивалентными, будет возвращено первое встретившееся. В противном случае min будет работать независимо от порядка ввода, если компаратор коммутативный. Компаратор по умолчанию < коммутативен только при отсутствии различий в типах.

Если comparator возвращает 0, и хотя бы одно значение — NaN, undefined или null, будет возвращено это значение.

Подобно min, но также принимает comparatorValueMapper, что позволяет сравнивать более сложными способами:

minBy<C>(comparatorValueMapper: (value: V, key: K, iter: this) => C,comparator?: (valueA: C, valueB: C) => number): V | undefined

const { List, } = require('immutable');
const l = List([
  { name: 'Bob', avgHit: 1 },
  { name: 'Max', avgHit: 3 },
  { name: 'Lili', avgHit: 2 } ,
]);
l.minBy(i => i.avgHit); // will output { name: 'Bob', avgHit: 1 }run it

Истина, если iter содержит все значения в этой коллекции.

isSubset(iter: Iterable<V>): boolean

Истина, если эта коллекция содержит все значения в iter.

isSuperset(iter: Iterable<V>): boolean