Стек

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

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

Порядок итерации предоставленной коллекции сохраняется в полученном Stack.

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

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

size: number

Псевдоним для Stack.first().

peek(): T | undefined

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

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

clear(): Stack<T>

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

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

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

Это очень эффективно для Стека.

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

Подобно Stack#unshift, но принимает коллекцию вместо аргументов.

unshiftAll(iter: Iterable<T>): Stack<T>

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

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

shift(): Stack<T>

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

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

Псевдоним для Stack#unshift и не эквивалентен List#push.

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

Псевдоним для Stack#unshiftAll.

pushAll(iter: Iterable<T>): Stack<T>

Псевдоним для Stack#shift и не эквивалентен List#pop.

pop(): Stack<T>

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

update<R>(updater: (value: this) => R): R

Например, чтобы суммировать 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

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

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

Map#withMutations

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

asMutable(): this

Map#asMutable

wasAltered(): boolean

Map#wasAltered

asImmutable(): this

Map#asImmutable

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

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

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

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

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

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

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

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

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

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

Как и 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}

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

Возвращает 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

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

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

hasIn(searchKeyPath: Iterable<unknown>): boolean

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

toMap(): Map<number, T>

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

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

toOrderedMap(): OrderedMap<number, T>

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

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

toSet(): Set<T>

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

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

toOrderedSet(): OrderedSet<T>

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

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

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) возвращает коллекцию из двух последних записей. Если не указано, новая коллекция начнётся с начала этой коллекции.

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

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

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

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