Collection.Indexed

Создает новую Collection.Indexed.

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

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

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

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

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

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

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

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

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

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

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

Если это коллекция кортежей пар [ключ, значение], она вернёт Seq.Keyed этих пар.

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

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

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

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

const { List } = require('immutable')
List([ 1, 2, 3 ]).interleave(List([ 'A', 'B', 'C' ]))
// List [ 1, "A", 2, "B", 3, "C" ]run it

Самая короткая коллекция останавливает вплетание.

List([ 1, 2, 3 ]).interleave(
  List([ 'A', 'B' ]),
  List([ 'X', 'Y', 'Z' ])
)
// List [ 1, "A", "X", 2, "B", "Y" ]run it

Поскольку interleave() повторно индексирует значения, она создаёт полную копию, что имеет сложность O(N).

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

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

index может быть отрицательным числом, которое индексирует назад с конца коллекции. s.splice(-2) выполняет вставку после второго с конца элемента.

const { List } = require('immutable')
List([ 'a', 'b', 'c', 'd' ]).splice(1, 2, 'q', 'r', 's')
// List [ "a", "q", "r", "s", "d" ]run it

Поскольку splice() повторно индексирует значения, она создаёт полную копию, что имеет сложность O(N).

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

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

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

Возвращает первый индекс в коллекции, где значение удовлетворяет предоставленной предикатной функции. В противном случае возвращается -1.

Возвращает последний индекс в коллекции, где значение удовлетворяет предоставленной предикатной функции. В противном случае возвращается -1.

Возвращает первое значение, для которого 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

Возвращает новый набор, в который добавлены другие наборы.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Итератор ключей этого 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

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

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

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

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

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

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

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

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

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