原文地址：http://facebook.github.io/immutable-js/
JavaScript的不可变数据集
Immutable一旦创建就不能被修改，可以使用软件开发更简单，无副作用的复制，高级记忆，使用简单逻辑改变侦探技术。持久化数据提供了一个灵活的api,用以产生新数据，而不是在对数据进行改变。
Immutable.js 提供了很多持久化数据结构，包括List,Stack,Map,OrderMap,Set,OrderedSet 和 Record。
由于使用了hash maps tries 和 vector tries的结构化分享机制，这些数据结构高效运行在现代JavaScript虚拟机里。
Immutable还提供了Seq，可以使用高效的集合链路方法，无须创建中间表现。
一、开始
使用npm安装immutable
npm install immutable
然后在模块中引用
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
浏览器
下载immutable.min.js，然后通过Script标签引入：
<script src="immutable.min.js"></script>
<script>
var map1 = Immutable.Map({a:1, b:2, c:3});
var map2 = map1.set('b', 50);
map1.get('b'); // 2
map2.get('b'); // 50
</script>
或者通过AMD加载器（如RequireJS）引入：
require(['./immutable.min.js'], function (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
});
二、关于数据持久化
应用开发大部分的难点在于追踪状态的变化和维持。Immutable给你提供了不同的方法去思考数据在程序中的流动。
在程序中订阅数据变化的事件会带来很大的开销，进而影响性能，甚至无法进行正确的数据同步。由于Immutable数据不可变，所以抛弃了数据的订阅机制。
Immutable的数据模型和React配合良好，尤其是使用了Flux思想的程序。
当数据从上而下传递而不是通过订阅时，你只需要专注于处理当前的逻辑。
Immutabe集合应该被当做values而不是objects. objects表示随着时间推移可能发生变化的对象，而values表示某个时间下的对象的状态。这点对于理解Immutable的正确使用非常关键。为了将Immutable 视作values, 请使用Immutable.is() 函数或者.equals()方法来判断相等性，不应该使用===操作符，因为===通过引用来判断一致性。
var map1 = Immutable.Map({a:1, b:2, c:3});
var map2 = map1.set('b', 2);
assert(map1.equals(map2) === true);
var map3 = map1.set('b', 50);
assert(map1.equals(map3) === false);
注意：出于性能优化的考虑，当一个操作产生相同的数据时，Immutable返回已经存在的数据，也就是引用也相同，方便===判断一致性。在Immutable的内部实现中，其实有用到了===操作符。
对于Immutable对象，它也可以通过复制引用来被复制。因为复制引用比复制整个对象来说，系统开销要小得多。
var map1 = Immutable.Map({a:1, b:2, c:3});
var clone = map1;
三、Javascript API
受Clojure, Scala, Haskell 和其他函数式编程语言的影响，Immutable将这些思想注入了Javascript。它提供了面向对象的API，类似于ES6的Array,Map和Set.
与传统的js数组方法不同，像Immutable.js的push,set,unshift,splice方法和slice,concat方法总是会返回新的immutable数据。
var list1 = Immutable.List.of(1, 2);
var list2 = list1.push(3, 4, 5);
var list3 = list2.unshift(0);
var list4 = list1.concat(list2, list3);
assert(list1.size === 2);
assert(list2.size === 5);
assert(list3.size === 6);
assert(list4.size === 13);
assert(list4.get(0) === 1);
Immutable.js里，Array有的方法，Immutable.List里几乎都有；Map有的方法，Immutable.Map里几乎都有；Set有的方法，Immutable.Set里几乎都有，包括遍历操作方法foreach()和map()。
var alpha = Immutable.Map({a:1, b:2, c:3, d:4});
alpha.map((v, k) => k.toUpperCase()).join();
// 'A,B,C,D'
接收原生的javascript对象
Immutable可以接收原生的javascript Array和Object.
var map1 = Immutable.Map({a:1, b:2, c:3, d:4});
var map2 = Immutable.Map({c:10, a:20, t:30});
var obj = {d:100, o:200, g:300};
var map3 = map1.merge(map2, obj);
// Map { a: 20, b: 2, c: 10, d: 100, t: 30, o: 200, g: 300 }
Immutable可以把JS 的 Array或者Object看成是可迭代的。你可以充分利用这点，对Object使用高级的集合方法。
因为Seq的懒惰性，它不缓存任何中间结果，所以这些操作是很高效的。
var myObject = {a:1,b:2,c:3};
Immutable.Seq(myObject).map(x => x * x).toObject();
// { a: 1, b: 4, c: 9 }
记住，当使用js对象来构造Immutable Maps时，js对象的属性必须是字符串格式。
var obj = { 1: "one" };
Object.keys(obj); // [ "1" ]
obj["1"]; // "one"
obj[1]; // "one"
var map = Immutable.fromJS(obj);
map.get("1"); // "one"
map.get(1); // undefined
转换为原生的javascript对象
所有可迭代的Immutable数据都可以通过toArray(),toObject或者toJs()转换成原生的javascript Array和Object. 所有可迭代的Immutable数据都实现了toJSON()方法，可以直接被JSON.stringify使用。
var deep = Immutable.Map({ a: 1, b: 2, c: Immutable.List.of(3, 4, 5) });
deep.toObject() // { a: 1, b: 2, c: List [ 3, 4, 5 ] }
deep.toArray() // [ 1, 2, List [ 3, 4, 5 ] ]
deep.toJS() // { a: 1, b: 2, c: [ 3, 4, 5 ] }
JSON.stringify(deep) // '{"a":1,"b":2,"c":[3,4,5]}'
拥抱ES6
Immutable充分利用ES6的特性。文中所有代码都是以ES6呈现的，如果需要在所有浏览器上运行，请把它转换成ES3.
// ES6
foo.map(x => x * x);
// ES3
foo.map(function (x) { return x * x; });
四、嵌套结构
Immutable数据容易使用嵌套，多层的树结构，类似JSON
var nested = Immutable.fromJS({a:{b:{c:[3,4,5]}}});
// Map { a: Map { b: Map { c: List [ 3, 4, 5 ] } } }
Immutable提供了一些非常有用的方法用以读取和操作嵌套数据。最常用到的就是mergeDeep, getIn, setIn, and updateIn，由List,Map和OrderedMap提供。
var nested2 = nested.mergeDeep({a:{b:{d:6}}});
// Map { a: Map { b: Map { c: List [ 3, 4, 5 ], d: 6 } } }
nested2.getIn(['a', 'b', 'd']); // 6
var nested3 = nested2.updateIn(['a', 'b', 'd'], value => value + 1);
// Map { a: Map { b: Map { c: List [ 3, 4, 5 ], d: 7 } } }
var nested4 = nested3.updateIn(['a', 'b', 'c'], list => list.push(6));
// Map { a: Map { b: Map { c: List [ 3, 4, 5, 6 ], d: 7 } } }
五、懒惰的Seq
Seq是不可变的——一旦Seq被创建，就不能被更改。
Seq是懒惰的——对于方法调用，Seq尽可能的少做操作。
比如，下面这段代码不做任何操作，因为Seq没有被使用：
var oddSquares = Immutable.Seq.of(1,2,3,4,5,6,7,8)
.filter(x => x % 2).map(x => x * x);
一旦Seq被使用，它就执行必要的操作。下面例子中，没有中间数组被创建，filter被调用 了3次，map只被调用了2次。
console.log(oddSquares.get(1));
通过.toSeq(),所有集合类型数据可以被转换成Seq.
var seq = Immutable.Map({a:1, b:1, c:1}).toSeq();
Seq允许链式操作：
seq.flip().map(key => key.toUpperCase()).flip().toObject();
// { A: 1, B: 1, C: 1 }
表达逻辑亦如此：
Immutable.Range(1, Infinity)
.skip(1000)
.map(n => -n)
.filter(n => n % 2 === 0)
.take(2)
.reduce((r, n) => r * n, 1);
// 1006008
六、判断相等
Immutable提供了纯数据的相等性判断（区别于引用判断）
var map1 = Immutable.Map({a:1, b:1, c:1});
var map2 = Immutable.Map({a:1, b:1, c:1});
assert(map1 !== map2); // two different instances
assert(Immutable.is(map1, map2)); // have equivalent values
assert(map1.equals(map2)); // alternatively use the equals method
Immutable.is()使用了跟Object.is一样的相等性判断机制。
七、批量变化
如果在返回之前，需要做一系列的数据变化，Immutable提供了withMutations方法用以批量变化来提升性能。
var list1 = Immutable.List.of(1,2,3);
var list2 = list1.withMutations(function (list) {
list.push(4).push(5).push(6);
});
assert(list1.size === 3);
assert(list2.size === 6);
重要：只有set,push,pop等少部分的方法可以在withMutations方法里使用。因为这些方法可以直接用在持久化数据结构上。而不像map,filter,sort和splice方法，会返回新的不可变数据结构，永远不会改变原来的变量。
