Map

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

Возвращает новую Map, также содержащую новую пару ключ-значение. Если в этой Map уже существует эквивалентный ключ, он будет заменён.

const { Map } = require('immutable')
const originalMap = Map()
const newerMap = originalMap.set('key', 'value')
const newestMap = newerMap.set('key', 'newer value')

originalMap
// Map {}
newerMap
// Map { "key": "value" }
newestMap
// Map { "key": "newer value" }run it

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

Возвращает новую Map, из которой исключён этот key.

Примечание: delete не может безопасно использоваться в IE8, но предоставляется для соответствия API коллекций ES6.

const { Map } = require('immutable')
const originalMap = Map({
  key: 'value',
  otherKey: 'other value'
})
// Map { "key": "value", "otherKey": "other value" }
originalMap.delete('otherKey')
// Map { "key": "value" }run it

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

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

const { Map } = require('immutable')
const names = Map({ a: "Aaron", b: "Barry", c: "Connor" })
names.deleteAll([ 'a', 'c' ])
// Map { "b": "Barry" }run it

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

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

const { Map } = require('immutable')
Map({ key: 'value' }).clear()
// Map {}run it

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

Как и merge(), mergeWith() возвращает новую Map, полученную в результате слияния предоставленных коллекций (или JS-объектов) в эту Map, но использует функцию merger для обработки конфликтов.

const { Map } = require('immutable')
const one = Map({ a: 10, b: 20, c: 30 })
const two = Map({ b: 40, a: 50, d: 60 })
one.mergeWith((oldVal, newVal) => oldVal / newVal, two)
// { "a": 0.2, "b": 0.5, "c": 30, "d": 60 }
two.mergeWith((oldVal, newVal) => oldVal / newVal, one)
// { "b": 2, "a": 5, "d": 60, "c": 30 }run it

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

Как merge(), но когда встречаются две совместимые коллекции с одинаковым ключом, они также объединяются, рекурсивно проходя по вложенным данным. Две коллекции считаются совместимыми (и, следовательно, будут объединены), если они обе относятся к одной из трёх категорий: с ключами (например, Mapы, Recordы и объекты), индексированные (например, Listы и массивы) или множества (например, Setы). Если они попадают в разные категории, mergeDeep заменит существующую коллекцию коллекцией, которая объединяется. Это поведение можно настроить, используя mergeDeepWith().

Примечание: Индексированные и множественные коллекции объединяются с использованием concat()/union() и поэтому не рекурсируют.

const { Map } = require('immutable')
const one = Map({ a: Map({ x: 10, y: 10 }), b: Map({ x: 20, y: 50 }) })
const two = Map({ a: Map({ x: 2 }), b: Map({ y: 5 }), c: Map({ z: 3 }) })
one.mergeDeep(two)
// Map {
//   "a": Map { "x": 2, "y": 10 },
//   "b": Map { "x": 20, "y": 5 },
//   "c": Map { "z": 3 }
// }run it

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

Как mergeDeep(), но когда встречаются два не-коллекции или несовместимые коллекции с одним и тем же ключом, она использует функцию merger для определения результирующего значения. Коллекции считаются несовместимыми, если они попадают в разные категории между с ключами, индексированными и множественными.

const { Map } = require('immutable')
const one = Map({ a: Map({ x: 10, y: 10 }), b: Map({ x: 20, y: 50 }) })
const two = Map({ a: Map({ x: 2 }), b: Map({ y: 5 }), c: Map({ z: 3 }) })
one.mergeDeepWith((oldVal, newVal) => oldVal / newVal, two)
// Map {
//   "a": Map { "x": 5, "y": 10 },
//   "b": Map { "x": 20, "y": 10 },
//   "c": Map { "z": 3 }
// }run it

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

Возвращает новую Map, установив value в этой keyPath. Если какие-либо ключи в keyPath не существуют, в этом ключе будет создана новая неизменяемая Map.

const { Map } = require('immutable')
const originalMap = Map({
  subObject: Map({
    subKey: 'subvalue',
    subSubObject: Map({
      subSubKey: 'subSubValue'
    })
  })
})

const newMap = originalMap.setIn(['subObject', 'subKey'], 'ha ha!') // Map { // "subObject": Map { // "subKey": "ha ha!", // "subSubObject": Map { "subSubKey": "subSubValue" } // } // } const newerMap = originalMap.setIn( ['subObject', 'subSubObject', 'subSubKey'], 'ha ha ha!' ) // Map { // "subObject": Map { // "subKey": "subvalue", // "subSubObject": Map { "subSubKey": "ha ha ha!" } // } // }Запустить

Простые JavaScript-объекты или массивы могут быть вложены в Immutable.js-коллекцию, и setIn() может обновлять эти значения, обрабатывая их неизменяемо, создавая новые копии этих значений с применёнными изменениями.

const { Map } = require('immutable')
const originalMap = Map({
  subObject: {
    subKey: 'subvalue',
    subSubObject: {
      subSubKey: 'subSubValue'
    }
  }
})

originalMap.setIn(['subObject', 'subKey'], 'ha ha!') // Map { // "subObject": { // subKey: "ha ha!", // subSubObject: { subSubKey: "subSubValue" } // } // }Запустить

Если какой-либо ключ в пути существует, но не может быть обновлён (такой как примитив, например, число, или пользовательский объект, например, Date), будет выброшено исключение.

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

Возвращает новую Map, удалив значение по этому keyPath. Если какие-либо ключи в keyPath не существуют, изменений не произойдёт.

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

Комбинация updateIn и merge, возвращающая новую Map, но выполняющая слияние в точке, достигнутой путём следования по пути ключа. Другими словами, эти две строки эквивалентны:

map.updateIn(['a', 'b', 'c'], abc => abc.merge(y))
map.mergeIn(['a', 'b', 'c'], y)

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

Комбинация updateIn и mergeDeep, возвращающая новую Map, но выполняющая глубокое слияние в точке, достигнутой путём следования по пути ключа. Другими словами, эти две строки эквивалентны:

map.updateIn(['a', 'b', 'c'], abc => abc.mergeDeep(y))
map.mergeDeepIn(['a', 'b', 'c'], y)

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

Каждый раз, когда вы вызываете одну из вышеперечисленных функций, создаётся новая неизменяемая Map. Если чистая функция вызывает несколько из этих функций для получения конечного возвращаемого значения, то была заплачена плата за производительность и память путём создания всех промежуточных неизменяемых Map.

Если вам нужно применить серию мутаций для создания новой неизменяемой Map, withMutations() создаёт временную изменяемую копию Map, которая может применять мутации высокопроизводительным способом. Фактически, именно так выполняются сложные мутации, такие как merge.

Например, это приводит к созданию 2, а не 4, новых Map:

const { Map } = require('immutable')
const map1 = Map()
const map2 = map1.withMutations(map => {
  map.set('a', 1).set('b', 2).set('c', 3)
})
assert.equal(map1.size, 0)
assert.equal(map2.size, 3)run it

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

Ещё один способ избежать создания промежуточных неизменяемых map — создать изменяемую копию этой коллекции. Изменяемые копии всегда возвращают this, и поэтому не должны использоваться для равенства. Ваша функция никогда не должна возвращать изменяемую копию коллекции, используйте её только внутри для создания новой коллекции.

Map#asImmutable

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

Примечание: если коллекция уже изменяемая, asMutable возвращает себя.

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

Возвращает true, если это изменяемая копия (см. asMutable()) и были применены изменяющие изменения.

Map#asMutable

Противоположность asMutable's yang. Поскольку она применяется к изменяемым коллекциям, эта операция является изменяемой и может вернуть себя (хотя может не вернуть себя, например, если результатом является пустая коллекция). После выполнения исходная изменяемая копия больше не должна изменяться, так как она может быть неизменяемым результатом.

Map#asMutable

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

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

Map({ a: 1, b: 2 }).map(x => 10 * x)
// Map { a: 10, b: 20 }

Collection.Keyed.mapKeys

Collection.Keyed.mapEntries

Применяет flat-map к Map, возвращая новую Map.

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

Collection.Keyed.flip

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

Возвращает 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 значений этой коллекции, отбрасывая ключи.

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

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

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

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

Хеш-код коллекции используется для определения потенциального равенства и используется при добавлении этой коллекции в 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.

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

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

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

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

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

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

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

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

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

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

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

Это аналогично 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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