redux-immutable

1. Map

• 当使用JS对象来创建不可变的Map时，尽管不可变数组允许任意类型值作为键，即使使用无引号缩写方式，js对象属性将会对待为字符串

const map1 = Map({
    1: "one"
})

console.log(map1.get("1"))
//one
console.log(map1.get(1))
// undefined

1.1 merge和mergeDeep

• 浅合并，新数据与旧数据进行对比，旧数据中不存在的属性直接添加,旧数据中已存在的属性用新数据中的覆盖。

const map1 = new Map({
    a: 111,
    b: 222,
    c: {
        d: 333,
        e: 444,
        a: 5555
    },
    f: 666
})

const map2 = new Map({
    a: 111,
    b: 222,
    c: {
        e: 444,
        f: 555
    }
})

const map3 = map1.merge(map2)
console.log(map3.toJS())
// { a: 111, b: 222, c: { e: 444, f: 555 }, f: 666 }，注意此处map2的c直接覆盖了map1的c。
const map4 = map1.mergeDeep(map2)
//{ a: 111, b: 222, c: { d: 333, e: 444, a: 5555, f: 555 }, f: 666 }
console.log(map4.toJS())

1.2 mergeWith

• 自定义浅合并，可自行设置某些属性的值

const map1 = new Map({
    a: 111,
    b: 222,
    c: {
        d: 333,
        e: 444,
        a: 5555
    },
    f: 666
})

const map2 = new Map({
    a: 111,
    b: 222333,
    c: {
        e: 444,
        f: 555
    }
})

const map5 = map1.mergeWith((oldData,newData, key)=> {
    if(key === "a") {
        return oldData
    }
    return newData
},map2)
// { a: 111, b: 222333, c: { e: 444, f: 555 }, f: 666 } 1111
console.log(map5.toJS(), 1111)

• 可以看到mergeWith，通过自定义的函数，当键为a的时候，用的是老数据，其他情况下用的是新数据。

1.3 mergeIn、mergeDeepIn

1.4 Map.isMap()

• 提供的值为Map时返回true。

1.5 size

const map1 = Map({
    1: "one",
    y: {
        a: "@2"
    }
})
console.log(map1.size)
//2

1.6 set

• 返回一个在原Map基础上包含了新的键值对的新Map。如果key在原函数中已经有相等的存在，那么他将会被替换。

1.7 delete

• 返回一个新的不包含key的新Map。

delete(key: K): this

1.8 deleteAll

• 返回一个不包含所有提供的key的新Map。

const map1 = Map({
    1: "one",
    y: {
        a: "@2"
    }
})

console.log(map1.deleteAll(["1", "y"]).toJS())
// {}

1.9 clear()

2.0 update

• 更新，第二个参数是个function，同时返回一个新的Map。注意：原先的map不变

const map1 = Map({
    1: "one",
    y: {
        a: "@2"
    }
})
console.log(map1.update("1", item=> 456).toJS(), map1.toJS())
// { '1': 456, y: { a: '@2' } } { '1': 'one', y: { a: '@2' } }

2.1 deleteIn()

• 返回一个移除了原MapkeyPath位置的新Map。如果keyPath处无值，那么将不会发生改变。

const map1 = Map({
    1: "one",
    y: {
        a: "@2"
    }
})

console.log(map1.deleteIn(["y", "a1"]).toJS())
// { '1': 'one', y: { a: '@2' } } 值没有发生改变

2.2 updateIn

2.3 concat

• 合并两个map

const map1 = Map({
    1: "one",
    y: {
        a: "@2"
    }
})

const map2 = Map({
    name: "3"
})

console.log(map1.concat(map2).toJS())
// { '1': 'one', y: { a: '@2' }, name: '3' }

2.4 map

• 遍历所有的值

2.5 mapEntries()

• 遍历所有的key，value

map1.mapEntries(([key,value])=> {
    console.log(key,value, "item1111")
})

2.6 filter

const map1 = Map({
    1: "one",
    y: {
        a: "@2"
    }
})

map1.filter((item,key)=> {
    console.log(item,key, "item1111")
})
// one 1 item1111
// { a: '@2' } y item1111

2.7 groupBy()

const listOfMaps = List([
    Map({ v: 0 }),
    Map({ v: 1 }),
    Map({ v: 1 }),
    Map({ v: 0 }),
    Map({ v: 2 })
  ])

const groupOf = listOfMaps.groupBy(x=> x.get("v"))

console.log(groupOf.toJS())
//{
  '0': [ { v: 0 }, { v: 0 } ],
  '1': [ { v: 1 }, { v: 1 } ],
  '2': [ { v: 2 } ]
}

2.8 has()

has(key: number): boolean

2.9 includes

• 判断values是否在collections

const map1 = Map({
    name: "222"
})

console.log(map1.includes("222"))
// true

2.9 first()

• 取得集合第一个值

const map1 = Map({
    name: "222"
})

console.log(map1.first())
// 22

3.0 last()

• 取得集合最后一个值。

3.1 getIn、hasIn

3.2 entries()

• 一个关于Collection条目的迭代器，是[ key, value ]这样的元组数据。

for(let [key,values] of map1.entries()){
    console.log(key, values)
}
// name 222
//sex female

3.3 values()

• 一个关于Collection值的迭代器。

for(let values of map1.values()){
    console.log(values)
}
// 222
// female

3.4 keys()

• 一个关于Collection键的迭代器。

const map1 = Map({
    name: "222",
    sex: "female"
})

for(let keys of map1.keys()){
    console.log(keys)
}
// name
// sex

3.5 keySeq()

• 返回一个只包含key的数组

3.6 valueSeq()

• 返回一个只包含value的数组

3.7 entrySeq()

• 返回一个新的Seq.Indexed，其为[key, value]这样的元组。

const map1 = Map({
    name: "222",
    sex: "female"
})

console.log(map1.entrySeq().toJS())
// [ [ 'name', '222' ], [ 'sex', 'female' ] ]

2. List

2.1 List.isList()

2.2 size

2.3 set

• 返回一个在index位置处值为value的新List。如果index位置已经定义了值，它将会被替换。

2.4 delete

2.5 insert

2.6 clear

2.7 push

2.8 pop

2.9 unshift

3.0 shift

3.1 update

• 将会返回一个新List，如果指定index位置在原List中存在，那么由所提供函数updater更新此位置值，否则该位置值设为所提供的notSetValue值。 如果只传入了一个参数updater，那么updater接受的参数为List本身。

const list1 = List([0])

console.log(list1.update(0, item=>2222).toJS())
// [2222]

3.2 merge、mergeWith、mergeDeep、mergIn、mergeDeepIn

3.3 setIn

3.4 deleteIn

• 返回一个删除了由keyPath指定位置值的新List。如果指定位置无值，那么不会发生改变。

3.5 updateIn

3.6 cancat、 map、 filter、reverse、groupBy、get、includes、first

3.7 indexOf

• 返回集合中最后一个与所提供的搜索值匹配的索引，无匹配值则返回-1。

3.8 findIndex()

3.9 find、findLast

3. is

• 用于比较两个不可变数据是否相等，包括Map的键值对和Set的成员。

const map1 = Map({ a: 1, b: 1, c: 1 })
const map2 = Map({ a: 1, b: 1, c: 1 })
console.log(map1 !== map2)
console.log(Object.is(map1, map2) === false)
console.log(is(map1, map2) === true)

4. Set

4.1 isSet

4.2 Set.intersect()

使用与另一个Set共有值创建新的不可变Set。

const intersected = Set.intersect([
    Set(["a", "b", "c"]),
    Set(["a","c"])
])

console.log(intersected.toJS())
// ["a", "c"]

4.3 Set.union()

const union = Set.union([
    Set(["a", "b", "c"]),
    Set(["a","c"])
])

console.log(union.toJS())
// [ 'a', 'c', 'b' ]

4.4 size

4.5 add、delete、clear

const set = Set([1,233])
console.log(set.add(7777).toJS())
// [ 1, 233, 7777 ]

4.6 map、filter、groupBy、hashCode、get、has、includes、last、getIn、hasIn

5. Stack

5.1 size

5.2 peek

• 弹出栈顶元素并返回

5.3 get、has、includes、first、 last、 clear

5.4 unshift、pop