Множество

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

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

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

Возвращает новое множество, которое также включает это значение.

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

Возвращает новое множество, из которого исключено это значение.

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

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

Возвращает новое множество, не содержащее значений.

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

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

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

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

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

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

const { OrderedSet } = require('immutable')
OrderedSet([ 1, 2, 3 ]).subtract([1, 3])
// OrderedSet [2]run it

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

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

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

Map#withMutations

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

Map#asMutable

Map#wasAltered

Map#asImmutable

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

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

Выполняет плоское отображение множества, возвращая новое множество.

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

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

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

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

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

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

Если 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, что позволяет сортировать более сложными способами:

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.

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

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.

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

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

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

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

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

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

Это полезно, если вы хотите работать с 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 значений этого объекта Collection, отбрасывая ключи.

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

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

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

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

Хэш-значение объекта 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Это аналогично 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, отбрасывая ключи. Выбрасывает исключение, если значения не являются хэшируемыми.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

const { List } = require('immutable')
List([ 'dog', 'frog', 'cat', 'hat', 'god' ])
  .skipWhile(x => x.match(/g/))
// List [ "cat", "hat", "god" ]run it

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

const { List } = require('immutable')
List([ 'dog', 'frog', 'cat', 'hat', 'god' ])
  .skipUntil(x => x.match(/hat/))
// List [ "hat", "god" ]run it

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

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

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

const { List } = require('immutable')
List([ 'dog', 'frog', 'cat', 'hat', 'god' ])
  .takeWhile(x => x.match(/o/))
// List [ "dog", "frog" ]run it

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

const { List } = require('immutable')
List([ 'dog', 'frog', 'cat', 'hat', 'god' ])
  .takeUntil(x => x.match(/at/))
// List [ "dog", "frog" ]run it

True, если predicate возвращает true для всех записей в коллекции.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 содержит каждое значение из этой коллекции.

True, если эта коллекция содержит каждое значение из iter.