Seq.Keyed

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

toJS(): {[key: string]: DeepCopy<V>}

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

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

toJSON(): {[key: string]: V}

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

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

toArray(): Array<[K, V]>

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

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

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

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

toSeq(): this

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

toKeyedSeq(): Seq.Keyed<K, V>

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

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

toSetSeq(): Seq.Set<V>

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

map<M>(mapper: (value: V, key: K, iter: this) => M,context?: unknown): Seq.Keyed<K, M>

const { Seq } = require('immutable')
Seq.Keyed({ a: 1, b: 2 }).map(x => 10 * x)
// Seq { "a": 10, "b": 20 }

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

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

flatMap<KM, VM>(mapper: (value: V, key: K, iter: this) => Iterable<[KM, VM]>,context?: unknown): Seq.Keyed<KM, VM>

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

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

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

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

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

mapKeys<M>(mapper: (key: K, value: V, iter: this) => M,context?: unknown): Seq.Keyed<M, V>

Collection.Keyed.mapKeys

mapEntries<KM, VM>(mapper: (entry: [K, V], index: number, iter: this) => [KM, VM] | undefined,context?: unknown): Seq.Keyed<KM, VM>

Collection.Keyed.mapEntries

flip(): Seq.Keyed<V, K>

Collection.Keyed.flip

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

keys(): IterableIterator<K>

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

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

values(): IterableIterator<V>

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

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

entries(): IterableIterator<[K, V]>

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

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

size: number | undefined

Например, Seq, возвращаемые из 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.

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

equals(other: unknown): boolean

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

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

hashCode(): number

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

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

has(key: K): boolean

True, если значение существует в этом наборе, используя хеш-код для определения равенства.

includes(value: V): boolean

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

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

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

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

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

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

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

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

toMap(): Map<K, V>

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

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

toOrderedMap(): OrderedMap<K, V>

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

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

toSet(): Set<V>

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

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

toOrderedSet(): OrderedSet<V>

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

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

toList(): List<V>

Это похоже на 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<V>

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

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

keySeq(): Seq.Indexed<K>

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

valueSeq(): Seq.Indexed<V>

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

entrySeq(): Seq.Indexed<[K, V]>

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

forEach(sideEffect: (value: V, key: K, 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: V, key: K, 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: V, key: K, 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: V, key: K, 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: V, key: K, 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: V, key: K, iter: this) => boolean,context?: unknown): boolean

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

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

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

join(separator?: string): string

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

isEmpty(): boolean

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

keyOf(searchValue: V): K | undefined

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

lastKeyOf(searchValue: V): K | undefined

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

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

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

Если два значения считаются эквивалентными, возвращается первое встреченное. В противном случае, max будет работать независимо от порядка ввода, если компаратор является коммутативным. Компаратор по умолчанию > коммутативен только, если типы не отличаются.

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

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

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

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

Если два значения считаются эквивалентными, возвращается первое встреченное. В противном случае, min будет работать независимо от порядка ввода, если компаратор является коммутативным. Компаратор по умолчанию < коммутативен только, если типы не отличаются.

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

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

minBy<C>(comparatorValueMapper: (value: V, key: K, iter: this) => C,comparator?: (valueA: C, valueB: C) => number): V | 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, если iter включает все значения в этом наборе.

isSubset(iter: Iterable<V>): boolean

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

isSuperset(iter: Iterable<V>): boolean