Seq.Indexed

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

Seq.Indexed<T>(collection?: Iterable<T> | ArrayLike<T>): Seq.Indexed<T>

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

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

toJS(): Array<DeepCopy<T>>

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

toJSON(): Array<T>

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

toArray(): Array<T>

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

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

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

Возвращает себя

toSeq(): this

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

size: number | undefined

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

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

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

cacheResult(): this

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.

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

equals(other: unknown): boolean

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

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

hashCode(): number

Хеш-код 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

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

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

has(key: number): boolean

Истина, если значение существует в этом 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

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

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 Collection, и getIn() может получить доступ к этим значениям:

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

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

hasIn(searchKeyPath: Iterable<unknown>): boolean

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

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

Например, чтобы просуммировать Seq после применения map и filter:

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

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

toMap(): Map<number, T>

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

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

toOrderedMap(): OrderedMap<number, T>

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

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

toSet(): Set<T>

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

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

toOrderedSet(): OrderedSet<T>

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

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

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

toStack(): Stack<T>

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

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

keySeq(): Seq.Indexed<number>

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

valueSeq(): Seq.Indexed<T>

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

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

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

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

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

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

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

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

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

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

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

rest(): this

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

butLast(): this

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

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>

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

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

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

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

isSubset(iter: Iterable<T>): boolean

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

isSuperset(iter: Iterable<T>): boolean