Seq.Set

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

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

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

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

toJS(): Array<DeepCopy<T>>

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

toJSON(): Array<T>

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

toArray(): Array<T>

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

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

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

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

toSeq(): this

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

toKeyedSeq(): Seq.Keyed<T, 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 с другими коллекциями, конкатенированными с этой.

concat<U>(...collections: Array<Iterable<U>>): Seq.Set<T | U>

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

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

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

Seq.Set([ 1, 2 ]).map(x => 10 * x)
// Seq { 10, 20 }

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

Flat-мапирует Seq, возвращая Seq того же типа.

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

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

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

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

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

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

values(): IterableIterator<T>

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

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

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

Примечание: это вернёт итератор 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: T): boolean

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

includes(value: T): boolean

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

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

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

last<NSV>(notSetValue?: NSV): T | 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<T, T>

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

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

toOrderedMap(): OrderedMap<T, T>

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

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

toSet(): Set<T>

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

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

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

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

keySeq(): Seq.Indexed<T>

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

valueSeq(): Seq.Indexed<T>

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

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

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

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

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

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

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

join(separator?: string): string

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

isEmpty(): boolean

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

keyOf(searchValue: T): T | undefined

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

lastKeyOf(searchValue: T): T | 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: T, 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: T, 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, если iter включает все значения в этом наборе.

isSubset(iter: Iterable<T>): boolean

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

isSuperset(iter: Iterable<T>): boolean