Список

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

List<T>(collection?: Iterable<T> | ArrayLike<T>): List<T>

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

const { List, Set } = require('immutable')

const emptyList = List()
// List []

const plainArray = [ 1, 2, 3, 4 ]
const listFromPlainArray = List(plainArray)
// List [ 1, 2, 3, 4 ]

const plainSet = Set([ 1, 2, 3, 4 ])
const listFromPlainSet = List(plainSet)
// List [ 1, 2, 3, 4 ]

const arrayIterator = plainArray[Symbol.iterator]()
const listFromCollectionArray = List(arrayIterator)
// List [ 1, 2, 3, 4 ]

listFromPlainArray.equals(listFromCollectionArray) // true
listFromPlainSet.equals(listFromCollectionArray) // true
listFromPlainSet.equals(listFromPlainArray) // truerun it

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

size: number

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

set(index: number, value: T): List<T>

Индекс index может быть отрицательным числом, что индексирует назад с конца списка. v.set(-1, "value") устанавливает последний элемент в списке.

Если index больше, чем size, размер возвращаемого списка size будет достаточно большим, чтобы включить index.

const originalList = List([ 0 ]);
// List [ 0 ]
originalList.set(1, 1);
// List [ 0, 1 ]
originalList.set(0, 'overwritten');
// List [ "overwritten" ]
originalList.set(2, 2);
// List [ 0, undefined, 2 ]

List().set(50000, 'value').size;
// 50001run it

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

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

delete(index: number): List<T>

Это синоним list.splice(index, 1).

Индекс index может быть отрицательным числом, что индексирует назад с конца списка. v.delete(-1) удаляет последний элемент из списка.

Примечание: delete нельзя безопасно использовать в IE8

List([ 0, 1, 2, 3, 4 ]).delete(0);
// List [ 1, 2, 3, 4 ]run it

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

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

Возвращает новый список с value по индексу index с размером на 1 больше, чем у этого списка. Значения с индексами выше index сдвигаются на 1 позицию.

insert(index: number, value: T): List<T>

Это синоним list.splice(index, 0, value).

List([ 0, 1, 2, 3, 4 ]).insert(6, 5)
// List [ 0, 1, 2, 3, 4, 5 ]run it

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

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

Возвращает новый список с размером 0 и без значений за константное время.

clear(): List<T>

List([ 1, 2, 3, 4 ]).clear()
// List []run it

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

Возвращает новый список, в который добавлен values, начиная с size этого списка.

push(...values: Array<T>): List<T>

List([ 1, 2, 3, 4 ]).push(5)
// List [ 1, 2, 3, 4, 5 ]run it

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

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

pop(): List<T>

Это отличается от Array#pop, так как возвращает новый список, а не удалённое значение. Используйте last() для получения последнего значения в этом списке.

List([ 1, 2, 3, 4 ]).pop()
// List[ 1, 2, 3 ]

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

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

unshift(...values: Array<T>): List<T>

List([ 2, 3, 4]).unshift(1);
// List [ 1, 2, 3, 4 ]run it

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

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

shift(): List<T>

Это отличается от Array#shift, так как возвращает новый список, а не удалённое значение. Используйте first() для получения первого значения в этом списке.

List([ 0, 1, 2, 3, 4 ]).shift();
// List [ 1, 2, 3, 4 ]run it

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

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

setSize(size: number): List<T>

При создании нового списка и предварительно известном конечном размере, использование setSize в сочетании с withMutations может привести к более эффективному созданию.

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

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

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

const { List } = require('immutable')
const list = List([ 0, 1, 2, List([ 3, 4 ])])
list.setIn([3, 0], 999);
// List [ 0, 1, 2, List [ 999, 4 ] ]run it

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

const { List } = require('immutable')
const list = List([ 0, 1, 2, { plain: 'object' }])
list.setIn([3, 'plain'], 'value');
// List([ 0, 1, 2, { plain: 'value' }])run it

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

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

deleteIn(keyPath: Iterable<unknown>): this

const { List } = require('immutable')
const list = List([ 0, 1, 2, List([ 3, 4 ])])
list.deleteIn([3, 0]);
// List [ 0, 1, 2, List [ 4 ] ]run it

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

const { List } = require('immutable')
const list = List([ 0, 1, 2, { plain: 'object' }])
list.removeIn([3, 'plain']);
// List([ 0, 1, 2, {}])run it

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

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

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

Map#mergeIn

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

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

Map#mergeDeepIn

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

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

Map#withMutations

Альтернативный API для withMutations()

asMutable(): this

Map#asMutable

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

wasAltered(): boolean

Map#wasAltered

asImmutable(): this

Map#asImmutable

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

concat<C>(...valuesOrCollections: Array<Iterable<C> | C>): List<T | C>

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

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

map<M>(mapper: (value: T, key: number, iter: this) => M,context?: unknown): List<M>

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

Плоская карта списка, возвращая новый список.

flatMap<M>(mapper: (value: T, key: number, iter: this) => Iterable<M>,context?: unknown): List<M>

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

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

filterNot(predicate: (value: T, key: number, 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: T, valueB: T) => 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: T, key: number, 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: T, key: number, iter: this) => G,context?: unknown): Seq.Keyed<G, Collection<number, T>>

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

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

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

toJS(): Array<DeepCopy<T>>

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

toJSON(): Array<T>

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

toArray(): Array<T>

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

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

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

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

has(key: number): boolean

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

includes(value: T): boolean

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

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

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

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

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

toSeq(): Seq.Indexed<T>

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

fromEntrySeq(): Seq.Keyed<unknown, unknown>

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

toKeyedSeq(): Seq.Keyed<number, T>

Это полезно, если вы хотите работать с 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<T>

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

toSetSeq(): Seq.Set<T>

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

interpose(separator: T): this

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

interleave(...collections: Array<Collection<unknown, T>>): this

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

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

splice(index: number, removeNum: number, ...values: Array<T>): this

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, если его нет.

indexOf(searchValue: T): number

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

lastIndexOf(searchValue: T): number

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

findIndex(predicate: (value: T, index: number, iter: this) => boolean,context?: unknown): number

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

findLastIndex(predicate: (value: T, index: number, iter: this) => boolean,context?: unknown): number

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

keyOf(searchValue: T): number | undefined

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

lastKeyOf(searchValue: T): number | undefined

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

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

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

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

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

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

maxBy<C>(comparatorValueMapper: (value: T, key: number, iter: this) => C,comparator?: (valueA: C, valueB: C) => number): T | 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: T, valueB: T) => number): T | undefined

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

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

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

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

minBy<C>(comparatorValueMapper: (value: T, key: number, iter: this) => C,comparator?: (valueA: C, valueB: C) => number): T | 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, если у этого и другого набора есть равенство значений, как определено 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

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

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

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

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

hasIn(searchKeyPath: Iterable<unknown>): boolean

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

toMap(): Map<number, T>

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

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

toOrderedMap(): OrderedMap<number, T>

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

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

toSet(): Set<T>

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

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

toOrderedSet(): OrderedSet<T>

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

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

toList(): List<T>

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

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

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

keys(): IterableIterator<number>

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

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

values(): IterableIterator<T>

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

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

entries(): IterableIterator<[number, T]>

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

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

keySeq(): Seq.Indexed<number>

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

valueSeq(): Seq.Indexed<T>

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

entrySeq(): Seq.Indexed<[number, T]>

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

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

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

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

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

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

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

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

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

rest(): this

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

butLast(): this

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

skip(amount: number): this

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

skipLast(amount: number): this

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

skipWhile(predicate: (value: T, key: number, 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: T, key: number, 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: T, key: number, 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: T, key: number, 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: T, key: number, iter: this) => boolean,context?: unknown): boolean

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

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

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

join(separator?: string): string

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

isEmpty(): boolean

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

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

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

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

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

isSubset(iter: Iterable<T>): boolean

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

isSuperset(iter: Iterable<T>): boolean