Эта статья является лишь кратким введением в Immutable.js, и в будущем мы продолжим рассказывать о его конкретных практических применениях.
Что такое неизменяемые данные?
Immutable data encourages pure functions (data-in, data-out) and lends itself to much simpler application development and enabling techniques from functional programming such as lazy evaluation.
-- Официальная документация описывает это
Неизменяемые данные — это данные, которые после создания не могут быть изменены. Любая модификация, добавление или удаление объекта Immutable возвращает новый объект Immutable. Принцип реализации ImmutableПостоянная структура данных, то есть при использовании старых данных для создания новых данных убедитесь, что старые данные одновременно доступны и неизменны. В то же время, чтобы избежать потери производительности, вызванной копированием всех узлов deepCopy, Immutable используетСтруктурный обмен, то есть, если узел в дереве объектов изменяется, изменяются только этот узел и затрагиваемый им родительский узел, а остальные узлы являются общими. Пожалуйста, посмотрите анимацию ниже:
Плюсы и минусы Immutable с первого взгляда
преимущество
1. Уменьшите сложность, которую приносит Mutable
Общее изменяемое состояние — корень всех зол, простой пример — присваивание ссылок в js:
var obj = { a: 1 };
var copy_obj = obj;
copy_obj.a = 2;
console.log(obj.a); // 2
Хотя назначение ссылок может сэкономить память, когда приложение сложное, состояние переменной часто становится кошмаром.Обычно общей практикой является использование мелкого или глубокого копирования, чтобы избежать модификации, но это вызывает потребление ЦП и памяти, но Immulate может очень решить эти проблемы. проблемы хорошо.
2. Экономьте место в памяти
Совместное использование структуры, упомянутое выше, Immutable.js использует этот метод для максимально возможного повторного использования памяти, и даже ранее используемые объекты могут быть повторно использованы повторно. Объекты, на которые нет ссылок, удаляются сборщиком мусора.
import { Map } from 'immutable';
let a = Map({
select: 'users',
filter: Map({ name: 'Cam' })
})
let b = a.set('select', 'people');
a === b; // false
a.get('filter') === b.get('filter'); // true
Выше a и b имеют общие неизменные узлы фильтра.
3. Отмена/восстановление, копирование/вставка, перемещение по желанию!
Поскольку данные каждый раз разные, пока эти данные хранятся в массиве, а соответствующие данные можно извлечь, куда бы вы ни захотели вернуться, легко разработать функцию отмены и повтора.
4. Используйте функциональное программирование
Неизменяемость (постоянная структура данных) сама по себе является концепцией функционального программирования.функциональное программированиеЧто касается отображения данных, императивное программирование связано с шагами для решения проблемы, а чисто функциональное программирование больше подходит для разработки интерфейса, чем объектно-ориентированное программирование. Потому что до тех пор, пока ввод непротиворечив, вывод должен быть непротиворечивым, и компоненты, разработанные таким образом, легче отлаживать и собирать.
недостаток
Оставив в стороне стоимость обучения и введенные дополнительные файлы ресурсов, давайте разберемся, что неудобно в процессе его использования.
1. Легко смешивается с нативными объектами
Основная причина заключается в том, что дизайн API Immutable похож на дизайн собственных объектов, из-за чего легко спутать операции. Например, операции Map и List:
// Immutable
const map = Map({ a: 1, b: 2 });
const list = List([1,2,3]);
// 原生js
const obj = { a: 1, b: 2 };
const arry = [1,2,3];
// 取值方式对比
console.log(map.get('a'));
console.log(list.get(0));
console.log(obj.a);
console.log(arry[0]);
Введение в Immutable.js
Инженер Facebook Ли Байрон потратил 3 года на его создание, и он появился примерно в то же время, что и React, но не был включен в набор инструментов React по умолчанию (React предоставляет упрощенный помощник). Он реализует полный набор постоянной структуры данных внутри, и существует множество простых в использовании типов данных. Например, Коллекция, Список, Карта, Набор, Запись, Последовательность. Есть очень полная карта, фильтр, группировка, сокращение и поиск функциональных методов работы. В то же время API также максимально похож на Object или Array.
Несколько типов данных Immutable.js
- Список: набор отсортированных индексов, аналогичный массиву в JavaScript.
- Map: неупорядоченный набор индексов, аналогичный Object в JavaScript.
- OrderedMap: упорядоченная карта, отсортированная в соответствии с set() данных.
- Набор: набор без повторяющихся значений.
- OrderedSet: упорядоченный набор, отсортированный в соответствии с добавлением данных.
- Стек: упорядоченная коллекция, которая поддерживает добавление и удаление с помощью unshift() и shift().
- Record: класс для создания экземпляров Record. Подобно объекту JavaScript, но принимает только определенную строку в качестве ключа со значением по умолчанию.
- Seq: Последовательность, но может не поддерживаться конкретной структурой данных.
- Коллекция: это базовый класс для построения всех структур данных, и его нельзя построить напрямую.
Наиболее часто используются List и Map, поэтому API этих двух типов данных в основном представлен здесь.
Общие API Immutable.js
fromJS()
Роль: преобразование данных js в данные неизменяемого типа.
использование:fromJS(value, converter)Введение: значение — это данные, которые нужно преобразовать, а конвертер — операция, которую необходимо выполнить. Второй параметр можно оставить пустым, по умолчанию массив будет преобразован в тип списка, объект будет преобразован в тип карты, а остальные операции не будут выполняться.
Код:
const obj = Immutable.fromJS({a:'123',b:'234'},function (key, value, path) {
console.log(key, value, path)
return isIndexed(value) ? value.toList() : value.toOrderedMap())
})
toJS()
Роль: преобразование неизменяемых данных в данные типа JS.
использование:value.toJS()
is()
Что делает: сравнивает два объекта.
использование:is(map1,map2)Введение: это отличается от сравнения объектов в js.В js сравнение двух объектов - это адрес, но в Immutable сравниваются hashCode и valueOf объекта.Пока hashCode двух объектов равен , значение то же, что позволяет избежать необходимости глубокого обхода, улучшенная производительность
Код:
import { Map, is } from 'immutable'
const map1 = Map({ a: 1, b: 1, c: 1 })
const map2 = Map({ a: 1, b: 1, c: 1 })
map1 === map2 //false
Object.is(map1, map2) // false
is(map1, map2) // true
Список() и Карта()
Роль: используется для создания нового объекта списка/карты. использование:
//List
Immutable.List(); // 空List
Immutable.List([1, 2]);
//Map
Immutable.Map(); // 空Map
Immutable.Map({ a: '1', b: '2' });
Список.isList() и Map.isMap()
Функция: определить, является ли структура данных типом списка/карты. использование:
List.isList([]); // false
List.isList(List()); // true
Map.isMap({}) // false
Map.isMap(Map()) // true
size
Функция: свойство, получение длины списка/карты, эквивалентной ImmutableData.count();
получить(), получить()
Роль: Получить данные в структуре данных
//获取List索引的元素
ImmutableData.get(0);
// 获取Map对应key的value
ImmutableData.get('a');
// 获取嵌套数组中的数据
ImmutableData.getIn([1, 2]);
// 获取嵌套map的数据
ImmutableData.getIn(['a', 'b']);
имеет (), имеет ()
Функция: определить, существует ли определенный ключ использование:
Immutable.fromJS([1,2,3,{a:4,b:5}]).has('0'); //true
Immutable.fromJS([1,2,3,{a:4,b:5}]).has('0'); //true
Immutable.fromJS([1,2,3,{a:4,b:5}]).hasIn([3,'b']) //true
includes()
Функция: определить, есть ли определенное значение использование:
Immutable.fromJS([1,2,3,{a:4,b:5}]).includes(2); //true
Immutable.fromJS([1,2,3,{a:4,b:5}]).includes('2'); //false 不包含字符2
Immutable.fromJS([1,2,3,{a:4,b:5}]).includes(5); //false
Immutable.fromJS([1,2,3,{a:4,b:5}]).includes({a:4,b:5}) //false
Immutable.fromJS([1,2,3,{a:4,b:5}]).includes(Immutable.fromJS({a:4,b:5})) //true
первый Последний()
Функция: используется для получения первого элемента или последнего элемента, если нет, возвращает неопределенное значение. Код:
Immutable.fromJS([1,2,3,{a:4,b:5}]).first()//1
Immutable.fromJS([1,2,3,{a:4,b:5}]).last()//{a:4,b:5}
Immutable.fromJS({a:1,b:2,c:{d:3,e:4}}).first() //1
Immutable.fromJS({a:1,b:2,c:{d:3,e:4}}).first() //{d:3,e:4}
модификация данных Примечание. Модификация данных здесь заключается в присвоении значения исходных данных новым данным, а исходные данные не будут изменены, поскольку Immutable — это неизменяемый тип данных.
установить набор ()
Функция: установить значение ключа и индекса первого слоя. использование:
const originalList = List([ 0 ]);
// List [ 0 ]
originalList.set(1, 1);
// List [ 0, 1 ]
originalList.set(0, 'overwritten');
// List [ "overwritten" ]
originalList.set(2, 2);
// List [ 0, undefined, 2 ]
List().set(50000, 'value').size;
// 50001
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" }
Когда используется список, установите индекс как числовое значение как значение. Когда карта используется, значение ключа устанавливается в значение.
При использовании в списке, если входящее число отрицательное, установите значение, индекс которого равен размеру + индексу, например, если вы передаете -1, установите значение размера-1 в качестве значения. Если значение входящего числа превышает длину Списка, то Список будет автоматически дополнен значением входящего числа, число будет установлено как значение, а остальные будут дополнены значением undefined.Примечание: В отличие от js, в List нет вакансий, если в [] List нет значения, оно не определено.
setIn()
Роль: установить значение свойства в глубинной структуре использование:
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!" }
// }
// }
Использование такое же, как и у set(), за исключением того, что первый параметр представляет собой массив, представляющий расположение устанавливаемого свойства.
удалить удалить
Роль: используется для удаления атрибутов в первом слое структуры. использование:
// List
List([ 0, 1, 2, 3, 4 ]).delete(0);
// List [ 1, 2, 3, 4 ]
// Map
const originalMap = Map({
key: 'value',
otherKey: 'other value'
})
// Map { "key": "value", "otherKey": "other value" }
originalMap.delete('otherKey')
// Map { "key": "value" }
deleteIn()
Используется для удаления глубоких данных, использование см. в setIn
deleteAll() (только для карты, а не для списка)
Функция: используется для удаления нескольких ключей на карте. Использование: deleteAll (ключи: Iterable): это Пример кода:
const names = Map({ a: "Aaron", b: "Barry", c: "Connor" })
names.deleteAll([ 'a', 'c' ])
// Map { "b": "Barry" }
обновить обновление ()
Функция: обновление атрибута в объекте и выполнение связанных операций с исходными данными. использование:
////List
const list = List([ 'a', 'b', 'c' ])
const result = list.update(2, val => val.toUpperCase())
///Map
const aMap = Map({ key: 'value' })
const newMap = aMap.update('key', value => value + value)
updateIn()
Ссылка на использование setIn
очистить очистить ()
Действие: очистить все данные
использование:clear(): thisПример кода:
Map({ key: 'value' }).clear() //Map
List([ 1, 2, 3, 4 ]).clear() // List
List中的各种删除与插入
List对应的数据结构是js中的数组，所以数组的一些方法在Immutable中也是通用的，比如push，pop,shift，
unshift，insert。
push()
Вставить элемент в конец списка
pop()
Удалить элемент из конца списка
unshift
Вставить элемент в начало списка
shift
Удалить элемент из головы списка
insert
Вставить элемент по индексу списка Код:
List([ 0, 1, 2, 3, 4 ]).insert(6, 5)
//List [ 0, 1, 2, 3, 4, 5 ]
List([ 1, 2, 3, 4 ]).push(5)
// List [ 1, 2, 3, 4, 5 ]
List([ 1, 2, 3, 4 ]).pop()
// List[ 1, 2, 3 ]
List([ 2, 3, 4]).unshift(1);
// List [ 1, 2, 3, 4 ]
List([ 0, 1, 2, 3, 4 ]).shift();
// List [ 1, 2, 3, 4 ]
В List также есть уникальный метод для установки длины списка, setSize().
List([]).setSize(2).toJS() //[undefined,undefined]
О слиянии
merge
Функция: неглубокое слияние, новые данные сравниваются со старыми данными, атрибуты, которых нет в старых данных, добавляются напрямую, а существующие атрибуты в данных перезаписываются теми, что в новых данных.
mergrWith
Роль: пользовательское мелкое слияние, вы можете установить значение некоторых свойств самостоятельно.
mergeIn
Функция: мелкое слияние глубоких данных
mergeDeep
Функция: глубокое слияние, атрибуты, которые существуют в старых и новых данных одновременно, являются данными после слияния новых и старых данных.
mergeDeepIn
Роль: глубокое слияние глубоких данных
mergrDeepWith
Роль: настроить глубокое слияние, вы можете установить значение некоторых свойств самостоятельно.
Вот пример, чтобы полностью понять слияние.Этот пример представляет собой структуру Map, и принцип List такой же, как и у Map.
const Map1 = Immutable.fromJS({a:111,b:222,c:{d:333,e:444}});
const Map2 = Immutable.fromJS({a:111,b:222,c:{e:444,f:555}});
const Map3 = Map1.merge(Map2);
//Map {a:111,b:222,c:{e:444,f:555}}
const Map4 = Map1.mergeDeep(Map2);
//Map {a:111,b:222,c:{d:333,e:444,f:555}}
const Map5 = Map1.mergeWith((oldData,newData,key)=>{
if(key === 'a'){
return 666;
}else{
return newData
}
},Map2);
//Map {a:666,b:222,c:{e:444,f:555}}
алгоритм последовательности
concat()
Функция: объединение объектов, использование такое же, как у concat() в массиве js, и возвращается новый объект.
использование:const List = list1.concat(list2)
map()
Функция: обход всего объекта, работа с элементами карты/списка и возврат нового объекта. использование:
Map({a:1,b:2}).map(val=>10*val)
//Map{a:10,b:20}
MapKey() для конкретной карты
Функция: обход всего объекта, работа с ключом элемента Map и возвращение нового объекта. использование:
Map({a:1,b:2}).mapKey(val=>val+'l')
//Map{al:10,bl:20}
Карта mapEntries()
Функция: обход всего объекта, одновременная работа с ключом и значением элемента карты и возврат нового объекта. Карта map() также может реализовать эту функцию. использование:
Map({a:1,b:2}).map((key,val)=>{
return [key+'l',val*10]
})
//Map{al:10,bl:20}
фильтр фильтр
Роль: возвращает новый объект, включая все элементы, соответствующие условиям фильтра. использование:
Map({a:1,b:2}).filter((key,val)=>{
return val == 2
})
//Map{b:2}
Существует также метод filterNot(), который является полной противоположностью этому методу.
реверс реверс
Роль: инвертировать структуру данных Пример кода:
Immutable.fromJS([1, 2, 3, 4, 5]).reverse();
// List [5,4,3,2,1]
Immutable.fromJS({a:1,b:{c:2,d:3},e:4}).recerse();
//Map {e:4,b:{c:2,d:3},a:1}
сортировать сортировать и сортировать по
Роль: сортировать структуру данных Пример кода:
///List
Immutable.fromJS([4,3,5,2,6,1]).sort()
// List [1,2,3,4,5,6]
Immutable.fromJS([4,3,5,2,6,1]).sort((a,b)=>{
if (a < b) { return -1; }
if (a > b) { return 1; }
if (a === b) { return 0; }
})
// List [1,2,3,4,5,6]
Immutable.fromJS([{a:3},{a:2},{a:4},{a:1}]).sortBy((val,index,obj)=>{
return val.get('a')
},(a,b)=>{
if (a < b) { return -1; }
if (a > b) { return 1; }
if (a === b) { return 0; }
})
//List [ {a:3}, {a:2}, {a:4}, {a:1} ]
//Map
Immutable.fromJS( {b:1, a: 3, c: 2, d:5} ).sort()
//Map {b: 1, c: 2, a: 3, d: 5}
Immutable.fromJS( {b:1, a: 3, c: 2, d:5} ).sort((a,b)=>{
if (a < b) { return -1; }
if (a > b) { return 1; }
if (a === b) { return 0; }
})
//Map {b: 1, c: 2, a: 3, d: 5}
Immutable.fromJS( {b:1, a: 3, c: 2, d:5} ).sortBy((value, key, obj)=> {
return value
})
//Map {b: 1, c: 2, a: 3, d: 5}
группа группаПо
Цель: группировать данные
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 } ],
// }
Найти данные
indexOf() , lastIndexOf Карта не существует для этого метода Функция: то же, что и метод в массиве js, найти значение индекса первого или последнего значения и вернуть -1, если не найдено использование:
Immutable.fromJS([1,2,3,4]).indexof(3) //2
Immutable.fromJS([1,2,3,4]).lastIndexof(3) //2
findIndex() , findLastIndex() Карта не существует для этого метода
Роль: найти значение индекса элемента, соответствующего требованиям. использование:
Immutable.fromJS([1,2,3,4]).findIndex((value,index,array)=>{
return value%2 === 0;
}) // 1
Immutable.fromJS([1,2,3,4]).findLastIndex((value,index,array)=>{
return index%2 === 0;
}) // 3
найти() , найтипоследний()
Роль: найти значение элемента, удовлетворяющее условию использование:
Immutable.fromJS([1,2,3,4]).find((value,index,array)=>{
return value%2 === 0;
}) // 2
Immutable.fromJS([1,2,3,4]).findLast((value,index,array)=>{
return value%2 === 0;
}) // 4
найтиКлюч(), найтиПоследнийКлюч()
Функция: найти значение ключа элемента, удовлетворяющего условию использование:
Immutable.fromJS([1,2,3,4]).findKey((value,index,array)=>{
return value%2 === 0;
}) // 1
Immutable.fromJS([1,2,3,4]).findLastKey((value,index,array)=>{
return value%2 === 0;
}) // 3
найтиВход(), найтиПоследнийВход()
Роль: найти пару ключ-значение ключ:значение элемента, удовлетворяющего условию использование:
Immutable.fromJS([1,2,3,4]).findEntry((value,index,array)=>{
return value%2 === 0;
}) // [1,2]
Immutable.fromJS([1,2,3,4]).findLastEntry((value,index,array)=>{
return value%2 === 0;
}) // [3,4]
keyOf() lastKeyOf()
Функция: найти ключевое значение, соответствующее значению использование:
Immutable.fromJS([1,2,3,4]).keyOf(2) //1
Immutable.fromJS([1,2,3,4]).lastKeyOf(2) //1
макс() , максби()
Роль: найти максимальное значение использование:
Immutable.fromJS([1, 2, 3, 4]).max() //4
Immutable.fromJS([{a;1},{a:2},{a: 3},{a:4}]).maxBy((value,index,array)=>{
return value.get('a')
}) //{a:4}
мин() , минBy()
Роль: найти минимальное значение использование:
Immutable.fromJS([1, 2, 3, 4]).min() //1
Immutable.fromJS([{a;1},{a:2},{a: 3},{a:4}]).minBy((value,index,array)=>{
return value.get('a')
}) //{a:1}
создать подмножество
slice()
Функция: Как и массив фрагментов массива в нативном js, он содержит два параметра, начало и конец, начало представляет начальную позицию перехвата, конец представляет конечную позицию, исключая конечный элемент. Если конец не включен, возвращается весь объект.Если конец отрицателен, возвращаются данные, соответствующие (начало, длина-конец). Если start только один и имеет отрицательное значение, возвращает последние конечные элементы. использование:
Immutable.fromJS([1, 2, 3, 4]).slice(0); //[1,2,3,4]
Immutable.fromJS([1, 2, 3, 4]).slice(0,2); //[1,2]
Immutable.fromJS([1, 2, 3, 4]).slice(-2); //[3,4]
Immutable.fromJS([1, 2, 3, 4]).slice(0,-2); //[1,2]
rest()
Функция: возвращает все элементы, кроме первого элемента. использование:
Immutable.fromJS([1, 2, 3, 4]).rest()//[2,3,4]
butLast()
Функция: возвращает все элементы, кроме последнего элемента. использование:
Immutable.fromJS([1, 2, 3, 4]).rest()//[1,2,3]
skip()
Функция: есть параметр n, который возвращает все оставшиеся элементы после усечения первых n элементов. использование:
Immutable.fromJS([1, 2, 3, 4]).skip(1)//[2,3,4]\
skipLast()
Функция: есть параметр n, который возвращает все оставшиеся элементы после усечения последних n элементов. использование:
Immutable.fromJS([1, 2, 3, 4]).skip(1)//[1,2,3]
skipWhile()
Функция: возвращает все элементы после первого возврата false
Immutable.fromJS([1, 2, 3, 4]).skipWhile(list.skipWhile((value,index,list)=>{
return value > 2;
}))// [1,2,3,4]
skipUntil()
Функция: возвращает все элементы после первого возврата true
Immutable.fromJS([1, 2, 3, 4]).skipUntil(list.skipWhile((value,index,list)=>{
return value > 2;
}))// [3,4]
take()
Функция: есть параметр n, вернуть первые n элементов использование:
Immutable.fromJS([1, 2, 3, 4]).take(2)//[1,2]
takeLast()
Роль: есть параметр n, вернуть последние n элементов использование:
Immutable.fromJS([1, 2, 3, 4]).takeLast(2)//[3,4]
takeWhile()
Функция: возвращает все элементы из первого return в false
Immutable.fromJS([1, 2, 3, 4]).skipWhile(list.takeWhile((value,index,list)=>{
return value > 2;
}))// []
takeUntil()
Функция: возвращает все элементы с первого раза, прежде чем вернуть true
Immutable.fromJS([1, 2, 3, 4]).skipUntil(list.takeUntil((value,index,list)=>{
return value > 2;
}))// [1,2]
Обработка данных
reduce()
Функция: такая же, как уменьшение массива в js, элементы обработки в порядке возрастания индекса использование:
Immutable.fromJS([1,2,3,4]).reduce((pre,next,index,arr)=>{
console.log(pre+next)
return pre+next;
})
// 3 6 10
reduceRight()
Функция: такая же, как уменьшение массива в js, элементы обработки в порядке убывания индекса использование:
Immutable.fromJS([1,2,3,4]).reduceRight((pre,next,index,arr)=>{
console.log(pre+next)
return pre+next;
})
// 7 9 10
every()
Функция: определить, соответствуют ли все элементы всего объекта определенному условию, и вернуть true, если они выполнены, иначе вернуть false.
Код:
Immutable.fromJS([1,2,3,4]).every((value,index,arr)=>{
return value > 2
}) // false
some()
Функция: определить, есть ли у всех элементов всего объекта элементы, удовлетворяющие определенному условию, если элементы есть, вернуть true, в противном случае вернуть false. Код:
Immutable.fromJS([1,2,3,4]).some((value,index,arr)=>{
return value > 2
}) // true
join()
Функция: То же, что и метод соединения массива в js. Преобразование стандарта в строку использование:
Immutable.fromJS([1,2,3,4]).join(',') //1,2,3,4
isEmpty()
Роль: определить, пусто ли оно использование:
Immutable.fromJS([]).isEmpty(); // true
Immutable.fromJS({}).isEmpty(); // true
count()
Функция: возвращает количество элементов, может настраивать условия и возвращает количество удовлетворенных условий. использование:
const list = Immutable.fromJS([1,2,3,4]);
const map = Immutable.fromJS({a:1,b:2,c:3,d:4});
list.count((value,index,list)=>{
return value > 2;
}) //2
map.count((value,index,list)=>{
return value > 2;
}) //2
countBy()
Функция: в отличие от count, countBy возвращает объект использование:
const list = Immutable.fromJS([1,2,3,4]);
const map = Immutable.fromJS({a:1,b:2,c:3,d:4});
list.countBy((value,index,list)=>{
return value > 2;
} //{false: 2, true: 2}
map.countBy((value,index,list)=>{
return value > 2;
} //{false: 2, true: 2}