OrderedSet

Создайте новый неизменяемый OrderedSet, содержащий значения из предоставленной коллекции.

Примечание: OrderedSet — это функция-фабрика, а не класс, и не использует ключевое слово new при создании.

Количество элементов в этом OrderedSet.

Возвращает OrderedSet, включающий любые значения из collections, которые ещё не существуют в этом OrderedSet.

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

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

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

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

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

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

Возвращает новый набор, не содержащий значений.

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

Возвращает набор, из которого удалены все значения, не содержащиеся также в collections.

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

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

const { OrderedSet } = require('immutable')
OrderedSet([ 1, 2, 3 ]).subtract([1, 3])
// OrderedSet [2]run it

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

Это может быть очень полезно для «цепочки» обычной функции в последовательности методов. 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

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

OrderedSet([ 1, 2 ]).map(x => 10 * x)
// OrderedSet [10, 20]

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

Аналогично set.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

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

Map#withMutations

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

Map#asMutable

Map#wasAltered

Map#asImmutable

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

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

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

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

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

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

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

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

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

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

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

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

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

Вычисляет и возвращает хэш-код для этого Collection.

Хэш-код Collection используется для определения потенциального равенства и используется при добавлении этого элемента в 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 пуст, возвращает необязательное значение по умолчанию, если оно предоставлено; в противном случае возвращает undefined.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Преобразует этот Collection в 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

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

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

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

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

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

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

Итератор пар [ключ, значение] этого Collection в виде кортежей [ key, value ].

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

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

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

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

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

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

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

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

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

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

Возвращает новый Collection того же типа, содержащий все записи, кроме первой.

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

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

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

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

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

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

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

Возвращает Seq.Keyed подсчетов, сгруппированных по возвращаемому значению функции 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.