OrderedMap

Количество записей в этом OrderedMap.

size: number

Возвращает новый OrderedMap, также содержащий новую пару ключ-значение. Если в этом OrderedMap уже существует эквивалентный ключ, он будет заменён, сохраняя при этом существующий порядок.

set(key: K, value: V): this

const { OrderedMap } = require('immutable')
const originalMap = OrderedMap({a:1, b:1, c:1})
const updatedMap = originalMap.set('b', 2)

originalMap
// OrderedMap {a: 1, b: 1, c: 1}
updatedMap
// OrderedMap {a: 1, b: 2, c: 1}run it

Примечание: set можно использовать в withMutations.

Возвращает новый Map, исключающий эту key.

delete(key: K): this

Примечание: delete небезопасно использовать в IE8, но предоставляется для соответствия API коллекций ES6.

const { Map } = require('immutable')
const originalMap = Map({
  key: 'value',
  otherKey: 'other value'
})
// Map { "key": "value", "otherKey": "other value" }
originalMap.delete('otherKey')
// Map { "key": "value" }run it

Примечание: delete можно использовать в withMutations.

Возвращает новый Map, исключающий указанные keys.

deleteAll(keys: Iterable<K>): this

const { Map } = require('immutable')
const names = Map({ a: "Aaron", b: "Barry", c: "Connor" })
names.deleteAll([ 'a', 'c' ])
// Map { "b": "Barry" }run it

Примечание: deleteAll можно использовать в withMutations.

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

clear(): this

const { Map } = require('immutable')
Map({ key: 'value' }).clear()
// Map {}run it

Примечание: clear можно использовать в withMutations.

Аналогично merge(), mergeWith() возвращает новый Map, полученный в результате слияния предоставленных коллекций (или JS-объектов) в этот Map, но использует функцию merger для обработки конфликтов.

mergeWith(merger: (oldVal: V, newVal: V, key: K) => V,...collections: Array<Iterable<[K, V]> | {[key: string]: V}>): this

const { Map } = require('immutable')
const one = Map({ a: 10, b: 20, c: 30 })
const two = Map({ b: 40, a: 50, d: 60 })
one.mergeWith((oldVal, newVal) => oldVal / newVal, two)
// { "a": 0.2, "b": 0.5, "c": 30, "d": 60 }
two.mergeWith((oldVal, newVal) => oldVal / newVal, one)
// { "b": 2, "a": 5, "d": 60, "c": 30 }run it

Примечание: mergeWith можно использовать в withMutations.

Аналогично merge(), но при обнаружении двух совместимых коллекций с одинаковым ключом, оно сливает их также, рекурсивно проходя по вложенным данным. Две коллекции считаются совместимыми (и, следовательно, будут объединены), если они обе относятся к одной из трёх категорий: ключи (например, Mapы, Recordы и объекты), индексы (например, Listы и массивы) или множества (например, Setы). Если они относятся к разным категориям, mergeDeep заменит существующую коллекцию на коллекцию, которая сливается. Это поведение можно настроить, используя mergeDeepWith().

mergeDeep(...collections: Array<Iterable<[K, V]> | {[key: string]: V}>): this

Примечание: Индексированные и множественные коллекции объединяются с использованием concat()/union() и поэтому не рекурсируют.

const { Map } = require('immutable')
const one = Map({ a: Map({ x: 10, y: 10 }), b: Map({ x: 20, y: 50 }) })
const two = Map({ a: Map({ x: 2 }), b: Map({ y: 5 }), c: Map({ z: 3 }) })
one.mergeDeep(two)
// Map {
//   "a": Map { "x": 2, "y": 10 },
//   "b": Map { "x": 20, "y": 5 },
//   "c": Map { "z": 3 }
// }run it

Примечание: mergeDeep можно использовать в withMutations.

Аналогично mergeDeep(), но когда встречаются два не-коллекции или несовместимые коллекции с одинаковым ключом, используется функция merger для определения результирующего значения. Коллекции считаются несовместимыми, если они относятся к различным категориям между ключами, индексами и множествами.

mergeDeepWith(merger: (oldVal: unknown, newVal: unknown, key: unknown) => unknown,...collections: Array<Iterable<[K, V]> | {[key: string]: V}>): this

const { Map } = require('immutable')
const one = Map({ a: Map({ x: 10, y: 10 }), b: Map({ x: 20, y: 50 }) })
const two = Map({ a: Map({ x: 2 }), b: Map({ y: 5 }), c: Map({ z: 3 }) })
one.mergeDeepWith((oldVal, newVal) => oldVal / newVal, two)
// Map {
//   "a": Map { "x": 5, "y": 10 },
//   "b": Map { "x": 20, "y": 10 },
//   "c": Map { "z": 3 }
// }run it

Примечание: mergeDeepWith можно использовать в withMutations.

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

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

OrderedMap({ a: 1, b: 2 }).map(x => 10 * x)
// OrderedMap { "a": 10, "b": 20 }

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

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

Collection.Keyed.mapKeys

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

Collection.Keyed.mapEntries

Выполняет плоское отображение OrderedMap, возвращая новый OrderedMap.

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

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

flip(): OrderedMap<V, K>

Collection.Keyed.flip

Возвращает новую коллекцию того же типа, содержащую только те записи, для которых функция 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

Возвращает новую карту, имеющую установленное значение value в этом keyPath. Если какие-либо ключи в keyPath отсутствуют, новая неизменяемая карта будет создана по этому ключу.

setIn(keyPath: Iterable<unknown>, value: unknown): this

const { Map } = require('immutable')
const originalMap = Map({
  subObject: Map({
    subKey: 'subvalue',
    subSubObject: Map({
      subSubKey: 'subSubValue'
    })
  })
})

const newMap = originalMap.setIn(['subObject', 'subKey'], 'ha ha!') // Map { // "subObject": Map { // "subKey": "ha ha!", // "subSubObject": Map { "subSubKey": "subSubValue" } // } // } const newerMap = originalMap.setIn( ['subObject', 'subSubObject', 'subSubKey'], 'ha ha ha!' ) // Map { // "subObject": Map { // "subKey": "subvalue", // "subSubObject": Map { "subSubKey": "ha ha ha!" } // } // }запустить

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

const { Map } = require('immutable')
const originalMap = Map({
  subObject: {
    subKey: 'subvalue',
    subSubObject: {
      subSubKey: 'subSubValue'
    }
  }
})

originalMap.setIn(['subObject', 'subKey'], 'ha ha!') // Map { // "subObject": { // subKey: "ha ha!", // subSubObject: { subSubKey: "subSubValue" } // } // }запустить

Если какой-либо ключ в пути существует, но не может быть обновлён (такой как примитив, например, число, или пользовательский объект, например, Date), будет выброшено исключение.

Примечание: setIn может использоваться в withMutations.

Возвращает новую карту, из которой удалено значение по этому keyPath. Если какие-либо ключи в keyPath отсутствуют, изменений не произойдёт.

deleteIn(keyPath: Iterable<unknown>): this

Примечание: deleteIn может использоваться в withMutations.

Сочетание updateIn и merge, возвращающее новую карту, но выполняющее слияние в точке, достигнутой путём следования по ключу. Другими словами, эти две строки эквивалентны:

mergeIn(keyPath: Iterable<unknown>, ...collections: Array<unknown>): this

map.updateIn(['a', 'b', 'c'], abc => abc.merge(y))
map.mergeIn(['a', 'b', 'c'], y)

Примечание: mergeIn может использоваться в withMutations.

Сочетание updateIn и mergeDeep, возвращающее новую карту, но выполняющее глубокое слияние в точке, достигнутой путём следования по ключу. Другими словами, эти две строки эквивалентны:

mergeDeepIn(keyPath: Iterable<unknown>, ...collections: Array<unknown>): this

map.updateIn(['a', 'b', 'c'], abc => abc.mergeDeep(y))
map.mergeDeepIn(['a', 'b', 'c'], y)

Примечание: mergeDeepIn может использоваться в withMutations.

Каждый раз, когда вы вызываете одну из вышеперечисленных функций, создаётся новая неизменяемая карта. Если чистая функция вызывает несколько из них для получения конечного возвращаемого значения, то на производительности и памяти оказывается штраф, создавая все промежуточные неизменяемые карты.

withMutations(mutator: (mutable: this) => unknown): this

Если вам нужно применить серию мутаций для создания новой неизменяемой карты, withMutations() создаёт временную изменяемую копию карты, которая может применять мутации высокопроизводительным способом. Фактически, именно так выполняются сложные мутации, такие как merge.

В качестве примера, это приводит к созданию 2, а не 4, новых карт:

const { Map } = require('immutable')
const map1 = Map()
const map2 = map1.withMutations(map => {
  map.set('a', 1).set('b', 2).set('c', 3)
})
assert.equal(map1.size, 0)
assert.equal(map2.size, 3)run it

Примечание: не все методы могут быть использованы на изменяемой коллекции или внутри withMutations! Прочитайте документацию для каждого метода, чтобы узнать, безопасно ли его использовать в withMutations.

Ещё один способ избежать создания промежуточных неизменяемых карт — создать изменяемую копию этой коллекции. Изменяемые копии всегда возвращают this, и поэтому не должны использоваться для равенства. Ваша функция никогда не должна возвращать изменяемую копию коллекции, используйте её только внутри для создания новой коллекции.

asMutable(): this

Map#asImmutable

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

Примечание: если коллекция уже изменяемая, asMutable возвращает себя.

Примечание: не все методы могут быть использованы на изменяемой коллекции или внутри withMutations! Прочитайте документацию для каждого метода, чтобы узнать, безопасно ли его использовать в withMutations.

Возвращает true, если это изменяемая копия (см. asMutable()), и были применены изменения.

wasAltered(): boolean

Map#asMutable

Ин-йана к asMutable. Поскольку он применяется к изменяемым коллекциям, эта операция является изменяемой и может вернуть себя (хотя может и не вернуть себя, т.е. если результат — пустая коллекция). После выполнения исходная изменяемая копия больше не должна изменяться, поскольку она может быть неизменяемым результатом.

asImmutable(): this

Map#asMutable

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

Глубоко преобразует эту коллекцию с ключами в эквивалентный родной JavaScript-объект.

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

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

Поверхностно преобразует эту коллекцию с ключами в эквивалентный родной 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>

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

equals(other: unknown): boolean

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

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

hashCode(): number

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

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

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

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

has(key: K): boolean

True, если значение существует в этой 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

Преобразует эту коллекцию в 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]>

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

True, если 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

True, если iter включает все значения в этой коллекции.

isSubset(iter: Iterable<V>): boolean

True, если эта коллекция включает все значения в iter.

isSuperset(iter: Iterable<V>): boolean