До сих пор большинство "стартовых шаблонов" и некоторые сообщения о реакции/сокращении, которые я видел, поощряют использование immutable.js для устранения изменчивости, Я лично полагаюсь на Object.assign или распространяет операторы, чтобы справиться с этим, поэтому на самом деле не вижу преимущества в immutable.js, поскольку он добавляет дополнительное обучение и немного меняет методы ванили js, используемые для изменчивости. Я пытался найти правильные причины для переключения, но не смог, следовательно, я прошу здесь посмотреть, почему он так популярен.
Преимущества использования immutable.js для операторов Object.assign или spread
Ответ 1
Это все об эффективности.
Стойкие структуры данных
Постоянная структура данных сохраняет предыдущие версии самой, когда она мутирована, всегда принося новую структуру данных. Чтобы избежать дорогостоящего клонирования, сохраняется только разница с предыдущей структурой данных, тогда как пересечение разделяется между ними. Эта стратегия называется структурным разделением. Следовательно, постоянные структуры данных намного эффективнее, чем клонирование с помощью Object.assign или оператора спреда.
Недостатки постоянных структур данных в Javascript
К сожалению, Javascript не поддерживает постоянные структуры данных изначально. Это причина, по которой immutable.js существует и что его объекты сильно отличаются от простого старого Javascript Object s. Это приводит к более подробному коду и большому количеству преобразований постоянных структур данных в собственные структуры данных Javascript.
Важнейший вопрос
Когда преимущества совместного использования (эффективности) immutable.js превышают его недостатки (многословие, конверсии)?
Я думаю, что библиотека окупается только в больших проектах с многочисленными и обширными объектами и коллекциями, когда клонирование целых структур данных и сборка мусора становится дороже.
Ответ 2
Я создал тесты производительности для нескольких неизменяемых библиотек, а script и результаты находятся внутри непременное назначение (проект GitHub), который показывает, что immutable.js оптимизирован для операций записи, быстрее чем Object.assign(), однако он медленнее для операций чтения, Ниже приведены результаты тестов:
-- Mutable
Total elapsed = 50 ms (read) + 53 ms (write) = 103 ms.
-- Immutable (Object.assign)
Total elapsed = 50 ms (read) + 2149 ms (write) = 2199 ms.
-- Immutable (immutable.js)
Total elapsed = 638 ms (read) + 1052 ms (write) = 1690 ms.
-- Immutable (seamless-immutable)
Total elapsed = 31 ms (read) + 91302 ms (write) = 91333 ms.
-- Immutable (immutable-assign (created by me))
Total elapsed = 50 ms (read) + 2173 ms (write) = 2223 ms.
Следовательно, использовать ли immutable.js или нет, будет зависеть от типа вашего приложения и его отношения чтения к записи. Если у вас много операций записи, то immutable.js будет хорошим вариантом.
В идеале вы должны профилировать свое приложение, прежде чем вводить какую-либо оптимизацию производительности, однако неизменность является одним из тех решений, решение которых должно быть принято на ранней стадии. Когда вы начинаете использовать immutable.js, вам нужно использовать его во всем своем приложении для получения преимуществ по производительности, поскольку взаимодействие с обычными объектами JS с использованием из JS() и toJS() является очень дорогостоящим.
Ответ 3
Я думаю, что основное преимущество ImmutableJs заключается в его структурах данных и скорости. Несомненно, это также обеспечивает неизменность, но вы должны делать это в любом случае, так что просто добавленная выгода.
Например, скажем, у вас очень большой объект в вашем редукторе, и вы хотите изменить очень небольшую часть этого объекта. Из-за неизменности вы не можете напрямую изменить объект, но вы должны создать копию объекта. Вы делаете это, копируя все (в ES6 с помощью оператора распространения).
Так в чем проблема? Копирование очень больших объектов происходит очень медленно. Структуры данных в ImmutableJS делают что-то, называемое структурным разделением, где вы действительно только изменяете нужные данные. Другие данные, которые вы не меняете, разделяются между объектами, поэтому они не копируются.
Результатом этого являются высокоэффективные структуры данных с быстрой записью.
ImmutableJS также предлагает легкие сравнения для глубоких объектов. Например
const a = Immutable.Map({ a: Immutable.Map({ a: 'a', b: 'b'}), b: 'b'});
const b = Immutable.Map({ a: Immutable.Map({ a: 'a', b: 'b'}), b: 'b'});
console.log(a.equals(b)) // true
Без этого вам понадобится какая-то функция глубокого сравнения, которая также займет много времени, тогда как корневые узлы здесь содержат хэш всей структуры данных (не цитируйте меня на этом, вот как Я помню это, но сравнения всегда мгновенные), поэтому сравнения всегда O(1) т.е. мгновенные, независимо от размера объекта.
Это может быть особенно полезно в методе React shouldComponentUpdate, где вы можете просто сравнить реквизиты, используя эту функцию equals, которая запускается мгновенно.
Конечно, есть и недостатки, если вы смешиваете структуры immutablejs и обычные объекты, может быть сложно сказать, что. Кроме того, ваша кодовая база усеяна синтаксисом immutableJS, который отличается от обычного Javascript.
Другой недостаток заключается в том, что если вы не собираетесь использовать глубоко вложенные объекты, это будет немного медленнее, чем простые старые js, так как структуры данных имеют некоторые накладные расходы.
Только мои 2 цента.
Ответ 4
Преимущество immutable.js заключается в том, что он обеспечивает неизменяемое хранилище редуктов (вы можете забыть продлить или выполнить неаккуратную работу по защите вашего хранилища от изменений) и упрощает сильные > редукторы много по сравнению с Object.assign или операторы распространения (оба являются мелкими, кстати!).
Как я уже сказал, я использовал redux + immutable в большом проекте Angular 1.x, и есть недостатки: проблемы с производительностью, неясно, что является неизменным, а что нет, Angular не может использовать immutable.js структуры в ng-repeat и т.д. Не уверены в Реате, хотелось бы услышать мнения.
Ответ 5
immutable.js предоставляет множество утилит, которые всегда возвращают новый объект.
Пример:
var Immutable = require('immutable');
var map1 = Immutable.Map({a:1, b:2, c:3});
var map2 = map1.set('b', 50);
map1.get('b'); // 2
map2.get('b'); // 50
Для просто реагирования/сокращения я лично считаю, что Object.assign достаточно мощный, но в некоторых случаях использование этой библиотеки может сэкономить вам несколько строк кода.
Ответ 6
Это связано не только с приростом производительности за счет постоянных структур данных. Невосприимчивость является очень желательным качеством сама по себе, поскольку она полностью устраняет любые ошибки, вызванные случайными мутациями. Кроме того, приятно иметь нормальные структуры данных с удобным API в Javascript, что-то действительно пригодное для использования, а immutable.js опережает объекты и массивы vanillla, даже с недавними дополнениями ES6 и ES7. Он похож на jQuery - он настолько популярен, что API действительно отличный и простой в использовании по сравнению с vanilla DOM API (который просто кошмар). Конечно, вы можете попытаться остаться неизменными с ванильными объектами, но тогда вы не должны забывать, что Object.assign и array spread КАЖДОЕ ВРЕМЯ FREAKING, а с immutable.js вы просто не ошибетесь, любые мутации здесь явны.