Seq

Некоторые Seq могут описывать свой размер лениво. В этом случае размер будет целым числом. В противном случае он будет неопределённым.

Например, Seq, возвращаемые из map() или reverse() сохраняют размер исходной Seq, в то время как filter() нет.

Примечание: Range, Repeat и Seq созданные из Array и Object всегда будут иметь размер.

Поскольку последовательности ленивые и предназначены для объединения, они не кэшируют свои результаты. Например, эта функция map вызывается в общей сложности 6 раз, поскольку каждая join итерирует Seq из трёх значений.

var squares = Seq([ 1, 2, 3 ]).map(x => x  x)
squares.join() + squares.join()

Если вы знаете, что Seq будет использоваться несколько раз, может быть эффективнее сначала кэшировать его в памяти. Здесь функция map вызывается только 3 раза.

var squares = Seq([ 1, 2, 3 ]).map(x => x  x).cacheResult()
squares.join() + squares.join()

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

Примечание: после вызова cacheResult, Seq всегда будет иметь size.

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

const { Seq } = require('immutable')
Seq([ 1, 2 ]).map(x => 10 * x)
// Seq [ 10, 20 ]

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

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

Аналогично seq.map(...).flatten(true). Примечание: используется только для множеств.

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

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() всегда возвращает новый экземпляр, даже если не фильтрует значения.

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

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

Если 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, что позволяет сортировать более сложными способами:

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.

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

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

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

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

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

Хеш-код коллекции используется для определения потенциального равенства и используется при добавлении в 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

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

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

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

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

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

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

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

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

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

Например, для суммирования 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

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

Collection.Indexed, и Collection.Set преобразуются в Array, в то время как Collection.Keyed преобразуются в Object, преобразуя ключи в строки.

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

Collection.Indexed, и Collection.Set преобразуются в Array, в то время как Collection.Keyed преобразуются в Object, преобразуя ключи в строки.

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

Collection.Indexed, и Collection.Set генерируют массив значений. Collection.Keyed генерируют массив пар [ключ, значение].

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

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

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

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

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

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

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

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

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

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

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

Это аналогично 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

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

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

Преобразует эту коллекцию в Seq того же типа (индексированная, с ключами или набор).

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

Это полезно, если вы хотите работать с 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 значений этой коллекции, отбрасывая ключи.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Для Seqs все записи будут присутствовать в результирующем Seq, даже если у них одинаковый ключ.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 включает все значения в этой коллекции.

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