Collection.Set

Аналогично Collection(), но всегда возвращает Collection.Set.

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

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

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

toJS(): Array<DeepCopy<T>>

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

toJSON(): Array<T>

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

toArray(): Array<T>

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

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

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

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

toSeq(): Seq.Set<T>

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

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

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

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

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

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

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

Выполняет flat-map для коллекции, возвращая коллекцию того же типа.

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

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

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

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

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

has(key: T): 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

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

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

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

Возвращает Seq.Keyed подсчётов, сгруппированных по результату вызова функции 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