Stack

Stack

Stack（栈）是一种支持复杂度为O(1)的高效添加和删除数据的集合，在栈顶添加和删除数据使用unshift(v)和shift()。

class Stack<T> extends Collection.Indexed<T>

为照顾习惯，Stack提供了push(v)，pop()和peek()，但请注意，这些都是在首部进行操作，这与List和JS数组不一样。

注意：reverse()或者任何从反方向的操作（reduceRight,lastIndexOf等）在Stack上都是效率不高的。

Stack是以单向链表实现的。

构造器

Stack()

使用提供的集合类值构建一个新的不可变Stack。

Stack(): Stack<any>
Stack<T>(): Stack<T>
Stack<T>(collection: Iterable<T>): Stack<T>

所提供的集合中的遍历顺序将会在生成的Stack中保存。

静态方法

Stack.isStack()

如果提供的值为Stack返回true。

Stack.isStack(maybeStack: any): boolean

Stack.of()

返回新的包含提供值的Stack。

Stack.of<T>(...values: Array<T>): Stack<T>

成员

size

size

读值

peek()

Stack.first()的别名。

peek(): T | undefined

get()

返回提供的索引位置关联的值，或者当提供的索引越界时返回所提供的notSetValue。

get<NSV>(index: number, notSetValue: NSV): T | NSV
get(index: number): T | undefined

继承自

Collection.Indexed#get

index可以为负值，表示从集合尾部开始索引。s.get(-1)取得集合最后一个元素。

has()

使用Immutable.is判断key值是否在Collection中。

has(key: number): boolean

继承自

Collection#has

includes()

使用Immutable.is判断value值是否在Collection中。

includes(value: T): boolean

继承自

Collection#includes

first()

取得集合第一个值。

first(): T | undefined

继承自

Collection#first

last()

取得集合第一个值。

last(): T | undefined

继承自

Collection#last

修改持久化

clear()

返回一个新的长度为0的不包含值的Stack。

claer(value: T): this

注意：claer可以在withMutations中使用。

unshift()

将提供的values放在原Stack首部，将其他值索引移至更高位，返回为新的Stack。

unshift(...values: Array<T>): Stack<T>

这个操作在Stack上非常高效。

注意：unshift可以在withMutations中使用。

unshiftAll()

和Stack#unshift相似，但接受一个集合而不是单个变量。

unshiftAll(iter: Iterable<T>): Stack<T>

注意：unshiftAll可以在withMutations中使用。

shift()

返回一个新的长度缩减一位的Stack，不包含原Stack第一位元素，将其他值索引移至更低位。

shift(): Stack<T>

注意：这与Array#shift效果不同，因其返回一个新的Stack而不是被移除的项。使用first()或者peek()来取得Stack中第一项值。

注意：shift可以在withMutations中使用。

push()

Stack#unshift的别名，与List#push不同。

push(...values: Array<T>): Stack<T>

pushAll()

Stack#unshiftAll的别名。

pushAll(iter: Iterable<T>): Stack<T>

pop()

Stack#shift的别名，与List#pop不同。

pop(): Stack<T>

update()

这将是一个很有用的方法来将两个普通方法进行链式调用。RxJS中为”let”，lodash中为”thru”。

update<R>(updater: (value: this) => R): R

继承自

Collection#update

例如，在进行map和filter操作后计算总和操作：

const { Seq } = require('immutable')
function sum(collection) {
  return collection.reduce((sum, x) => sum + x, 0)
}
Map({ x: 1, y: 2, z: 3 })
  .map(x => x + 1)
  .filter(x => x % 2 === 0)
  .update(sum)
// 6

临时改变

withMutations()

注意：只有部分方法可以被可变的集合调用或者在withMutations中调用！查看文档中各个方法看他是否允许在withMuataions中调用。

withMutations(mutator: (mutable: this) => any): this

见

Map#withMutations

asMutable()

注意：只有部分方法可以被可变的集合调用或者在withMutations中调用！查看文档中各个方法看他是否允许在withMuataions中调用。

asMutable(): this

见

Map#asMutable

asImmutable()

asImmutable(): this

见

Map#asImmutable

序列算法

cancat()

将其他的值或者集合与这个Set串联起来返回为一个新Set。

concat<C>(...valuesOrCollections: Array<Iterable<C> | C>): Set<T | C>

覆盖

Collection#concat

map()

返回一个由传入的mapper函数处理过值的新Set。

map<M>(mapper: (value: T, key: number, iter: this) => M, context?: any): Set<M>

覆盖

Collection#map

例

Set([ 1, 2 ]).map(x => 10 * x)
// Set [ 10, 20 ]

注意：map()总是返回一个新的实例，即使它产出的每一个值都与原始值相同。

flatMap()

扁平化这个Set为一个新Set。

flatMap<M>(
mapper: (value: T, key: number, iter: this) => Iterable<M>,
context?: any
): Set<M>

覆盖

Collection#flatMap

与set.map(...).flatten(true)相似。

filter()

返回一个只有由传入方法predicate返回为true的值组成的新Set。

filter<F>(
predicate: (value: T, index: number, iter: this) => boolean,
context?: any
): Set<F>
filter(
predicate: (value: T, index: number, iter: this) => any,
context?: any
): this

覆盖

Collection#filter

注意：filter()总是返回一个新的实例，即使它的结果没有过滤掉任何一个值。

[Symbol.iterator]

[Symbol.iterator](): IterableIterator<T>

继承自

Collection.Set#[Symbol.iterator]

filterNot()

返回一个由所提供的predicate方法返回false过滤的新的相同类型的集合。

filterNot(
    predicate: (value: T, key: number, iter: this) => boolean,
    context?: any
): this

继承自

Collection#filterNot

例

const { Map } = require('immutable')
Map({ a: 1, b: 2, c: 3, d: 4}).filterNot(x => x % 2 === 0)
// Map { "a": 1, "c": 3 }

注意：filterNot总是返回一个新的实例，即使它没有过滤掉任何一个值。

reverse()

返回为一个逆序的新的同类型集合。

reverse(): this

继承自

Collection#reverse

sort()

返回一个使用传入的comparator重新排序的新同类型集合。

sort(comparator?: (valueA: T, valueB: T) => number): this

继承自

Collection#sort

如果没有提供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 }

注意：sort()总是返回一个新的实例，即使它没有改变排序。

sortBy()

与sort类似，但能接受一个comparatorValueMapper方法，它允许通过更复杂的方式进行排序：

sortBy<C>(
    comparatorValueMapper: (value: T, key: number, iter: this) => C,
    comparator?: (valueA: C, valueB: C) => number
): this

继承自

Collection#sortBy

例

hitters.sortBy(hitter => hitter.avgHits)

注意：sortBy()总是返回一个新的实例，即使它没有改变排序。

groupBy()

返回一个Collection.Keyeds的Collection.keyed，由传入的grouper方法分组。

groupBy<G>(
    grouper: (value: T, key: number, iter: this) => G,
    context?: any
): Seq.Keyed<G, Collection<number, T>>

继承自

Collection#groupBy

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 } ],
// }

map()

返回一个由传入的mapper函数处理过值的新Set。

map<M>(mapper: (value: T, key: number, iter: this) => M, context?: any): Set<M>

覆盖

Collection#map

例

Set([ 1, 2 ]).map(x => 10 * x)
// Set [ 10, 20 ]

注意：map()总是返回一个新的实例，即使它产出的每一个值都与原始值相同。

flatMap()

扁平化这个Set为一个新Set。

flatMap<M>(
mapper: (value: T, key: number, iter: this) => Iterable<M>,
context?: any
): Set<M>

覆盖

Collection#flatMap

与set.map(...).flatten(true)相似。

filter()

返回一个只有由传入方法predicate返回为true的值组成的新Set。

filter<F>(
predicate: (value: T, index: number, iter: this) => boolean,
context?: any
): Set<F>
filter(
predicate: (value: T, index: number, iter: this) => any,
context?: any
): this

覆盖

Collection#filter

注意：filter()总是返回一个新的实例，即使它的结果没有过滤掉任何一个值。

[Symbol.iterator]

[Symbol.iterator](): IterableIterator<T>

继承自

Collection.Set#[Symbol.iterator]

filterNot()

返回一个由所提供的predicate方法返回false过滤的新的相同类型的集合。

filterNot(
    predicate: (value: T, key: number, iter: this) => boolean,
    context?: any
): this

继承自

Collection#filterNot

例

const { Map } = require('immutable')
Map({ a: 1, b: 2, c: 3, d: 4}).filterNot(x => x % 2 === 0)
// Map { "a": 1, "c": 3 }

注意：filterNot总是返回一个新的实例，即使它没有过滤掉任何一个值。

reverse()

返回为一个逆序的新的同类型集合。

reverse(): this

继承自

Collection#reverse

sort()

返回一个使用传入的comparator重新排序的新同类型集合。

sort(comparator?: (valueA: T, valueB: T) => number): this

继承自

Collection#sort

如果没有提供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 }

注意：sort()总是返回一个新的实例，即使它没有改变排序。

sortBy()

与sort类似，但能接受一个comparatorValueMapper方法，它允许通过更复杂的方式进行排序：

sortBy<C>(
    comparatorValueMapper: (value: T, key: number, iter: this) => C,
    comparator?: (valueA: C, valueB: C) => number
): this

继承自

Collection#sortBy

例

hitters.sortBy(hitter => hitter.avgHits)

注意：sortBy()总是返回一个新的实例，即使它没有改变排序。

groupBy()

返回一个Collection.Keyeds的Collection.keyed，由传入的grouper方法分组。

groupBy<G>(
    grouper: (value: T, key: number, iter: this) => G,
    context?: any
): Seq.Keyed<G, Collection<number, T>>

继承自

Collection#groupBy

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 } ],
// }

转换为JavaScript类型

toJS()

深层地将这个有序的集合转换转换为原生JS数组。

toJS(): Array<any>

继承自

Collection.Index#toJS

toJSON()

浅转换这个有序的集合为原生JS数组。

toJSON(): Array<any>

继承自

Collection.Index#toJSON

toArray()

浅转换这个有序的集合为原生JS数组并且丢弃key。

toArray(): Array<any>

继承自

Collection#toArray

toObject()

浅转换这个有序的集合为原生JS对象。

toObject(): {[key: string]: V}

继承自

Collection#toObject

转换为Seq

toSeq()

返回Seq.Indexed。

toSeq(): Seq.Indexed<T>

继承自

Collection.Indexed#toSeq

fromEntrySeq()

如果这个集合是由[key, value]这种原组构成的，那么这将返回这些原组的Seq.Keyed。

fromEntrySeq(): Seq.Keyed<any, any>

继承自

Collection.Index#fromEntrySeq

toKeyedSeq()

从这个集合返回一个Seq.Keyed，其中索引将视作key。

toKeyedSeq(): Seq.Keyed<number, T>

继承自

Collection#toKeyedSeq

如果你想对Collection.Indexed操作返回一组[index, value]对，这将十分有用。

返回的Seq将与Colleciont有相同的索引顺序。

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" }

toIndexedSeq()

将这个集合的值丢弃键(key)返回为Seq.Indexed。

toIndexedSeq(): Seq.Indexed<T>

继承自

Collection#toIndexedSeq

toSetSeq()

将这个集合的值丢弃键(key)返回为Seq.Set。

toSetSeq(): Seq.Set<T>

继承自

Collection#toSetSeq

组合

interpose()

返回一个在原集合每两个元素之间插入提供的separator的同类型集合。

interpose(separator: T): this

继承自

COllection.Indexed#interpose

interleave()

返回一个原集合与所提供collections交叉的痛类型集合。

interleave(...collections: Array<Collection<any, T>>): this

继承自

Collection.Indexed#interleave

返回的集合依次包含第一个集合元素与第二个集合元素。

const { List } = require('immutable')
List([ 1, 2, 3 ]).interleave(List([ 'A', 'B', 'C' ]))
// List [ 1, "A", 2, "B", 3, "C"" ]

由最短的集合结束交叉。

List([ 1, 2, 3 ]).interleave(
  List([ 'A', 'B' ]),
  List([ 'X', 'Y', 'Z' ])
)
// List [ 1, "A", "X", 2, "B", "Y"" ]

splice()

返回一个由指定值替换了原集合某个范围的值的新的有序集合。如果没提供替换的值，那么会跳过要删除的范围。

splice(index: number, removeNum: number, ...values: Array<T>): this

继承自

Collection.Indexed#splice

index可以为负值，表示从集合结尾开始索引。s.splice(-2)表示倒数第二个元素开始拼接。

const { List } = require('immutable')
List([ 'a', 'b', 'c', 'd' ]).splice(1, 2, 'q', 'r', 's')
// List [ "a", "q", "r", "s", "d" ]

flatten()

压平嵌套的集合。

flatten(depth?: number): Collection<any, any>
flatten(shallow?: boolean): Collection<any, any>

继承自

Collection#flatten

默认会深度地经常压平集合操作，返回一个同类型的集合。可以指定depth为压平深度或者是否深度压平（为true表示仅进行一层的浅层压平）。如果深度为0（或者shllow:false）将会深层压平。

压平仅会操作其他集合，数组和对象不会进行此操作。

注意：flatten(true)操作是在集合上进行，同时返回一个集合。

查找

indexOf()

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

indexOf(searchValue: T): number

继承自

Collection.Indexed#indexOf

lastIndexOf()

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

lastIndexOf(searchValue: T): number

继承自

Collection.Indexed#lastIndexOf

findIndex()

返回集合中第一个符合与所提供的断言的索引，均不符合则返回-1。

findIndex(
    predicate: (value: T, index: number, iter: this) => boolean,
    context?: any
): number

继承自

Collection.Indexed#findIndex

findLastIndex()

返回集合中最后一个符合与所提供的断言的索引，均不符合则返回-1。

findLastIndex(
    predicate: (value: T, index: number, iter: this) => boolean,
    context?: any
): number

继承自

Collection.Indexed#findLastIndex

find()

返回集合中第一个符合与所提供的断言的值。

find(
    predicate: (value: T, key: number, iter: this) => boolean,
    context?: any,
    notSetValue?: T
): T | undefined

继承自

Collection#find

findLast()

返回集合中最后一个符合与所提供的断言的值。

findLast(
    predicate: (value: T, key: number, iter: this) => boolean,
    context?: any,
    notSetValue?: T
): T | undefined

继承自

Collection#findLast

注意：predicate将会逆序地在每个值上调用。

findEntry()

返回第一个符合所提供断言的值的[key， value]。

findEntry(
    predicate: (value: T, key: number, iter: this) => boolean,
    context?: any,
    notSetValue?: T
): [number, T] | undefined

继承自

Collection#findEntry

findLastEntry()

返回最后一个符合所提供断言的值的[key， value]。

findLastEntry(
    predicate: (value: T, key: number, iter: this) => boolean,
    context?: any,
    notSetValue?: T
): [number, T] | undefined

继承自

Collection#findLastEntry

注意：predicate将会逆序地在每个值上调用。

findKey()

返回第一个predicate返回为true的键。

findKey(
    predicate: (value: T, key: number, iter: this) => boolean,
    context?: any
): number | undefined

继承自

Collection#findKey

findLastKey()

返回最后一个predicate返回为true的键。

findLastKey(
    predicate: (value: T, key: number, iter: this) => boolean,
    context?: any
): number | undefined

继承自

Collection#findLastKey

注意：predicate将会逆序地在每个值上调用。

keyOf()

返回与提供的搜索值关联的键，或者undefined。

keyOf(searchValue: T): number | undefined

继承自

Collection#keyOf

lastKeyOf()

返回最后一个与提供的搜索值关联的键或者undefined。

lastKeyOf(searchValue: T): number | undefined

继承自

Collection#lastKeyOf

max()

返回集合中最大的值。如果有多个值比较为相等，那么将返回第一个。

max(comparator?: (valueA: T, valueB: T) => number): T | undefined

继承自

Collection#max

comparator的使用方法与Collection#sort是一样的，如果未提供那么默认的比较为>。

当两个值比较为相等时，第一个遇见的值将会被返回。另一方面，如果comparator是可交换的，那么max将会独立于输入的顺序。默认的比较器>只有在类型不一致时才可交换。

如果comparator返回0或者值为NaN、undefined或者null，这个值将会被返回。

maxBy()

和max类似，但还能接受一个comparatorValueMapper来实现更复杂的比较。

maxBy<C>(
    comparatorValueMapper: (value: T, key: number, iter: this) => C,
    comparator?: (valueA: C, valueB: C) => number
): T | undefined

继承自

Collection#maxBy

例

hitters.maxBy(hitter => hitter.avgHits)

min()

返回集合中最小的值，如果有多个值比较为相等，将会返回第一个。

min(comparator?: (valueA: T, valueB: T) => number): T | undefined

继承自

Collection#min

当两个值比较为相等时，第一个遇见的值将会被返回。另一方面，如果comparator是可交换的，那么min将会独立于输入的顺序。默认的比较器<只有在类型不一致时才可交换。

如果comparator返回0或者值为NaN、undefined或者null，这个值将会被返回。

minBy()

和min类似，但还能接受一个comparatorValueMapper来实现更复杂的比较。

minBy<C>(
    comparatorValueMapper: (value: T, key: number, iter: this) => C,
    comparator?: (valueA: C, valueB: C) => number
): T | undefined

继承自

Collection#minBy

例

hitters.minBy(hitter => hitter.avgHits)

查找

indexOf()

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

indexOf(searchValue: T): number

继承自

Collection.Indexed#indexOf

lastIndexOf()

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

lastIndexOf(searchValue: T): number

继承自

Collection.Indexed#lastIndexOf

findIndex()

返回集合中第一个符合与所提供的断言的索引，均不符合则返回-1。

findIndex(
    predicate: (value: T, index: number, iter: this) => boolean,
    context?: any
): number

继承自

Collection.Indexed#findIndex

findLastIndex()

返回集合中最后一个符合与所提供的断言的索引，均不符合则返回-1。

findLastIndex(
    predicate: (value: T, index: number, iter: this) => boolean,
    context?: any
): number

继承自

Collection.Indexed#findLastIndex

find()

返回集合中第一个符合与所提供的断言的值。

find(
    predicate: (value: T, key: number, iter: this) => boolean,
    context?: any,
    notSetValue?: T
): T | undefined

继承自

Collection#find

findLast()

返回集合中最后一个符合与所提供的断言的值。

findLast(
    predicate: (value: T, key: number, iter: this) => boolean,
    context?: any,
    notSetValue?: T
): T | undefined

继承自

Collection#findLast

注意：predicate将会逆序地在每个值上调用。

findEntry()

返回第一个符合所提供断言的值的[key， value]。

findEntry(
    predicate: (value: T, key: number, iter: this) => boolean,
    context?: any,
    notSetValue?: T
): [number, T] | undefined

继承自

Collection#findEntry

findLastEntry()

返回最后一个符合所提供断言的值的[key， value]。

findLastEntry(
    predicate: (value: T, key: number, iter: this) => boolean,
    context?: any,
    notSetValue?: T
): [number, T] | undefined

继承自

Collection#findLastEntry

注意：predicate将会逆序地在每个值上调用。

findKey()

返回第一个predicate返回为true的键。

findKey(
    predicate: (value: T, key: number, iter: this) => boolean,
    context?: any
): number | undefined

继承自

Collection#findKey

findLastKey()

返回最后一个predicate返回为true的键。

findLastKey(
    predicate: (value: T, key: number, iter: this) => boolean,
    context?: any
): number | undefined

继承自

Collection#findLastKey

注意：predicate将会逆序地在每个值上调用。

keyOf()

返回与提供的搜索值关联的键，或者undefined。

keyOf(searchValue: T): number | undefined

继承自

Collection#keyOf

lastKeyOf()

返回最后一个与提供的搜索值关联的键或者undefined。

lastKeyOf(searchValue: T): number | undefined

继承自

Collection#lastKeyOf

max()

返回集合中最大的值。如果有多个值比较为相等，那么将返回第一个。

max(comparator?: (valueA: T, valueB: T) => number): T | undefined

继承自

Collection#max

comparator的使用方法与Collection#sort是一样的，如果未提供那么默认的比较为>。

当两个值比较为相等时，第一个遇见的值将会被返回。另一方面，如果comparator是可交换的，那么max将会独立于输入的顺序。默认的比较器>只有在类型不一致时才可交换。

如果comparator返回0或者值为NaN、undefined或者null，这个值将会被返回。

maxBy()

和max类似，但还能接受一个comparatorValueMapper来实现更复杂的比较。

maxBy<C>(
    comparatorValueMapper: (value: T, key: number, iter: this) => C,
    comparator?: (valueA: C, valueB: C) => number
): T | undefined

继承自

Collection#maxBy

例

hitters.maxBy(hitter => hitter.avgHits)

min()

返回集合中最小的值，如果有多个值比较为相等，将会返回第一个。

min(comparator?: (valueA: T, valueB: T) => number): T | undefined

继承自

Collection#min

当两个值比较为相等时，第一个遇见的值将会被返回。另一方面，如果comparator是可交换的，那么min将会独立于输入的顺序。默认的比较器<只有在类型不一致时才可交换。

如果comparator返回0或者值为NaN、undefined或者null，这个值将会被返回。

minBy()

和min类似，但还能接受一个comparatorValueMapper来实现更复杂的比较。

minBy<C>(
    comparatorValueMapper: (value: T, key: number, iter: this) => C,
    comparator?: (valueA: C, valueB: C) => number
): T | undefined

继承自

Collection#minBy

例

hitters.minBy(hitter => hitter.avgHits)

等值比较

equals()

如果当前集合和另一个集合比较为相等，那么返回true，是否相等由Immutable.is()定义。

equals(other: any): boolean

继承自

Collection#equals

注意：此方法与Immutable.is(this, other)等效，提供此方法是为了方便能够链式地使用。

hashCode()

计算并返回这个集合的哈希值。

hashCode(): number

继承自

Collection#hashCode

集合的hashCode用于确定两个集合的相等性，在添加到Set或者被作为Map的键值时用于检测两个实例是否相等而会被使用到。

const a = List([ 1, 2, 3 ]);
const b = List([ 1, 2, 3 ]);
assert(a !== b); // different instances
const set = Set([ a ]);
assert(set.has(b) === true);

当两个值的hashCode相等时，并不能完全保证他们是相等的，但当他们的hashCode不同时，他们一定是不等的。

读取深层数据

getIn()

返回根据提供的路径或者索引搜索到的嵌套的值。

getIn(searchKeyPath: Iterable<any>, notSetValue?: any): any

继承自

Collection#getIn

hasIn()

根据提供的路径或者索引检测该处是否设置了值。

hasIn(searchKeyPath: Iterable<any>): boolean

继承自

Collection#hasIn

转换为集合

toMap()

将此集合转换为Map，如果键不可哈希，则抛弃。

toMap(): Map<number, T>

继承自

Collection#toMap

注意：这和Map(this.toKeyedSeq())等效，为了能够方便的进行链式调用而提供。

toOrderedMap()

将此集合转换为Map，保留索引的顺序。

toOrderedMap(): OrderedMap<number, T>

继承自

Collection#toOrderedMap

注意：这和OrderedMap(this.toKeyedSeq())等效，为了能够方便的进行链式调用而提供。

toSet()

将此集合转换为Set，如果值不可哈希，则抛弃。

toSet(): Set<T>

继承自

Collection#toSet

注意：这和Set(this)等效，为了能够方便的进行链式调用而提供。

toOrderSet()

将此集合转换为Set，保留索引的顺序。

toOrderedSet(): OrderedSet<T>

继承自

Collection#toOrderedSet

注意：这和OrderedSet(this.valueSeq())等效，为了能够方便的进行链式调用而提供。

toList()

将此集合转换为List，丢弃键值。

toList(): List<T>

继承自

Collection#toList

此方法和List(collection)类似，为了能够方便的进行链式调用而提供。然而，当在Map或者其他有键的集合上调用时，collection.toList()会丢弃键值，同时创建一个只有值的list，而List(collection)使用传入的元组创建list。

const { Map, List } = require('immutable')
var myMap = Map({ a: 'Apple', b: 'Banana' })
List(myMap) // List [ [ "a", "Apple" ], [ "b", "Banana" ] ]
myMap.toList() // List [ "Apple", "Banana" ]

toStack()

将此集合转换为Stack，丢弃键值，抛弃不可哈希的值。

toStack(): Stack<T>

注意：这和Stack(this)等效，为了能够方便的进行链式调用而提供。

迭代器

keys()

一个关于Collection键的迭代器。

keys(): IterableIterator<number>

继承自

Collection#keys

注意：此方法将返回ES6规范的迭代器，并不支持Immutable.js的sequence算法，你可以尝试使用keySeq来满足需求。

values()

一个关于Collection值的迭代器。

values(): IterableIterator<T>

继承自

Collection#values

注意：此方法将返回ES6规范的迭代器，并不支持Immutable.js的sequence算法，你可以尝试使用valueSeq来满足需求。

entries()

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

entries(): IterableIterator<[number, T]>

继承自

Collection#entries

注意：此方法将返回ES6规范的迭代器，并不支持Immutable.js的sequence算法，你可以尝试使用entrySeq来满足需求。

集合（Seq）

keySeq()

返回一个新的Seq.Indexed，其包含这个集合的键值。

keySeq(): Seq.Indexed<number>

继承自

Collection#keySeq

valueSeq()

返回一个新的Seq.Indexed，其包含这个集合的所有值。

valueSeq(): Seq.Indexed<T>

继承自

Collection#valueSeq

entrySeq()

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

entrySeq(): Seq.Indexed<[number, T]>

继承自

Collection#entrySeq

副作用

forEach()

sideEffect将会对集合上每个元素执行。

forEach(
    sideEffect: (value: T, key: number, iter: this) => any,
    context?: any
): number

继承自

Collection#forEach

与Array#forEach不同，任意一个sideEffect返回false都会停止循环。函数将返回所有参与循环的元素（包括最后一个返回false的那个）。

创建子集

slice()

返回一个新的相同类型的相当于原集合指定范围的元素集合，包含开始索引但不包含结束索引位置的值。

slice(begin?: number, end?: number): this

继承自

Collection#slice

如果起始值为负，那么表示从集合结束开始查找。例如slice(-2)返回集合最后两个元素。如果没有提供，那么新的集合将会从最开始那个元素开始。

如果终止值为负，表示从集合结束开始查找。例如silice(0, -1)返回除集合最后一个元素外所有元素。如果没提供，新的集合将会包含到原集合最后一个元素。

如果请求的子集与原集合相等，那么将会返回原集合。

rest()

返回一个不包含原集合第一个元素的新的同类型的集合。

rest(): this

继承自

Collection#rest

butLast()

返回一个不包含原集合最后一个元素的新的同类型的集合。

butLast(): this

继承自

Collection#butLast

skip()

返回一个不包含原集合从头开始amount个数元素的新的同类型集合。

skip(amount: number): this

继承自

Collection#skip

skipLast()

返回一个不包含原集合从结尾开始amount个数元素的新的同类型集合。

skipLast(amount: number): this

继承自

Collection#skipLast

skipWhile()

返回一个原集合从predicate返回false那个元素开始的新的同类型集合。

skipWhile(
    predicate: (value: T, key: number, iter: this) => boolean,
    context?: any
): this

继承自

Collection#skipWhile

例

const { List } = require('immutable')
List([ 'dog', 'frog', 'cat', 'hat', 'god' ])
  .skipWhile(x => x.match(/g/))
// List [ "cat", "hat", "god" ]

skipUntil()

返回一个原集合从predicate返回true那个元素开始的新的同类型集合。

skipUntil(
predicate: (value: T, key: number, iter: this) => boolean,
context?: any
): this

继承自

Collection#skipUntil

例

const { List } = require('immutable')
List([ 'dog', 'frog', 'cat', 'hat', 'god' ])
  .skipUntil(x => x.match(/hat/))
// List [ "hat", "god"" ]

take()

返回一个包含原集合从头开始的amount个元素的新的同类型集合。

take(amount: number): this

继承自

Collection#take

takeLast()

返回一个包含从原集合结尾开始的amount个元素的新的同类型集合。

takeLast(amount: number): this

继承自

Collection#take

takeWhile()

返回一个包含原集合从头开始的prediacte返回true的那些元素的新的同类型集合。

takeWhile(
    predicate: (value: T, key: number, iter: this) => boolean,
    context?: any
): this

继承自

Collection#takeWhile

例

const { List } = require('immutable')
List([ 'dog', 'frog', 'cat', 'hat', 'god' ])
  .takeWhile(x => x.match(/o/))
// List [ "dog", "frog" ]

takeUntil()

返回一个包含原集合从头开始的prediacte返回false的那些元素的新的同类型集合。

takeUntil(
    predicate: (value: T, key: number, iter: this) => boolean,
    context?: any
): this

继承自

Collection#takeUntil

例

const { List } = require('immutable')
List([ 'dog', 'frog', 'cat', 'hat', 'god' ])
  .takeUntil(x => x.match(/at/))
// List [ "dog", "frog" ]

读取深层数据

getIn()

返回根据提供的路径或者索引搜索到的嵌套的值。

getIn(searchKeyPath: Iterable<any>, notSetValue?: any): any

继承自

Collection#getIn

hasIn()

根据提供的路径或者索引检测该处是否设置了值。

hasIn(searchKeyPath: Iterable<any>): boolean

继承自

Collection#hasIn

转换为集合

toMap()

将此集合转换为Map，如果键不可哈希，则抛弃。

toMap(): Map<number, T>

继承自

Collection#toMap

注意：这和Map(this.toKeyedSeq())等效，为了能够方便的进行链式调用而提供。

toOrderedMap()

将此集合转换为Map，保留索引的顺序。

toOrderedMap(): OrderedMap<number, T>

继承自

Collection#toOrderedMap

注意：这和OrderedMap(this.toKeyedSeq())等效，为了能够方便的进行链式调用而提供。

toSet()

将此集合转换为Set，如果值不可哈希，则抛弃。

toSet(): Set<T>

继承自

Collection#toSet

注意：这和Set(this)等效，为了能够方便的进行链式调用而提供。

toOrderSet()

将此集合转换为Set，保留索引的顺序。

toOrderedSet(): OrderedSet<T>

继承自

Collection#toOrderedSet

注意：这和OrderedSet(this.valueSeq())等效，为了能够方便的进行链式调用而提供。

toList()

将此集合转换为List，丢弃键值。

toList(): List<T>

继承自

Collection#toList

此方法和List(collection)类似，为了能够方便的进行链式调用而提供。然而，当在Map或者其他有键的集合上调用时，collection.toList()会丢弃键值，同时创建一个只有值的list，而List(collection)使用传入的元组创建list。

const { Map, List } = require('immutable')
var myMap = Map({ a: 'Apple', b: 'Banana' })
List(myMap) // List [ [ "a", "Apple" ], [ "b", "Banana" ] ]
myMap.toList() // List [ "Apple", "Banana" ]

toStack()

将此集合转换为Stack，丢弃键值，抛弃不可哈希的值。

toStack(): Stack<T>

注意：这和Stack(this)等效，为了能够方便的进行链式调用而提供。

迭代器

keys()

一个关于Collection键的迭代器。

keys(): IterableIterator<number>

继承自

Collection#keys

注意：此方法将返回ES6规范的迭代器，并不支持Immutable.js的sequence算法，你可以尝试使用keySeq来满足需求。

values()

一个关于Collection值的迭代器。

values(): IterableIterator<T>

继承自

Collection#values

注意：此方法将返回ES6规范的迭代器，并不支持Immutable.js的sequence算法，你可以尝试使用valueSeq来满足需求。

entries()

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

entries(): IterableIterator<[number, T]>

继承自

Collection#entries

注意：此方法将返回ES6规范的迭代器，并不支持Immutable.js的sequence算法，你可以尝试使用entrySeq来满足需求。

集合（Seq）

keySeq()

返回一个新的Seq.Indexed，其包含这个集合的键值。

keySeq(): Seq.Indexed<number>

继承自

Collection#keySeq

valueSeq()

返回一个新的Seq.Indexed，其包含这个集合的所有值。

valueSeq(): Seq.Indexed<T>

继承自

Collection#valueSeq

entrySeq()

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

entrySeq(): Seq.Indexed<[number, T]>

继承自

Collection#entrySeq

副作用

forEach()

sideEffect将会对集合上每个元素执行。

forEach(
    sideEffect: (value: T, key: number, iter: this) => any,
    context?: any
): number

继承自

Collection#forEach

与Array#forEach不同，任意一个sideEffect返回false都会停止循环。函数将返回所有参与循环的元素（包括最后一个返回false的那个）。

创建子集

slice()

返回一个新的相同类型的相当于原集合指定范围的元素集合，包含开始索引但不包含结束索引位置的值。

slice(begin?: number, end?: number): this

继承自

Collection#slice

如果起始值为负，那么表示从集合结束开始查找。例如slice(-2)返回集合最后两个元素。如果没有提供，那么新的集合将会从最开始那个元素开始。

如果终止值为负，表示从集合结束开始查找。例如silice(0, -1)返回除集合最后一个元素外所有元素。如果没提供，新的集合将会包含到原集合最后一个元素。

如果请求的子集与原集合相等，那么将会返回原集合。

rest()

返回一个不包含原集合第一个元素的新的同类型的集合。

rest(): this

继承自

Collection#rest

butLast()

返回一个不包含原集合最后一个元素的新的同类型的集合。

butLast(): this

继承自

Collection#butLast

skip()

返回一个不包含原集合从头开始amount个数元素的新的同类型集合。

skip(amount: number): this

继承自

Collection#skip

skipLast()

返回一个不包含原集合从结尾开始amount个数元素的新的同类型集合。

skipLast(amount: number): this

继承自

Collection#skipLast

skipWhile()

返回一个原集合从predicate返回false那个元素开始的新的同类型集合。

skipWhile(
    predicate: (value: T, key: number, iter: this) => boolean,
    context?: any
): this

继承自

Collection#skipWhile

例

const { List } = require('immutable')
List([ 'dog', 'frog', 'cat', 'hat', 'god' ])
  .skipWhile(x => x.match(/g/))
// List [ "cat", "hat", "god" ]

skipUntil()

返回一个原集合从predicate返回true那个元素开始的新的同类型集合。

skipUntil(
predicate: (value: T, key: number, iter: this) => boolean,
context?: any
): this

继承自

Collection#skipUntil

例

const { List } = require('immutable')
List([ 'dog', 'frog', 'cat', 'hat', 'god' ])
  .skipUntil(x => x.match(/hat/))
// List [ "hat", "god"" ]

take()

返回一个包含原集合从头开始的amount个元素的新的同类型集合。

take(amount: number): this

继承自

Collection#take

takeLast()

返回一个包含从原集合结尾开始的amount个元素的新的同类型集合。

takeLast(amount: number): this

继承自

Collection#take

takeWhile()

返回一个包含原集合从头开始的prediacte返回true的那些元素的新的同类型集合。

takeWhile(
    predicate: (value: T, key: number, iter: this) => boolean,
    context?: any
): this

继承自

Collection#takeWhile

例

const { List } = require('immutable')
List([ 'dog', 'frog', 'cat', 'hat', 'god' ])
  .takeWhile(x => x.match(/o/))
// List [ "dog", "frog" ]

takeUntil()

返回一个包含原集合从头开始的prediacte返回false的那些元素的新的同类型集合。

takeUntil(
    predicate: (value: T, key: number, iter: this) => boolean,
    context?: any
): this

继承自

Collection#takeUntil

例

const { List } = require('immutable')
List([ 'dog', 'frog', 'cat', 'hat', 'god' ])
  .takeUntil(x => x.match(/at/))
// List [ "dog", "frog" ]

减少值

reduce()

将传入的方法reducer在集合每个元素上调用并传递缩减值，以此来缩减集合的值。

reduce<R>(
    reducer: (reduction: R, value: T, key: number, iter: this) => R,
    initialReduction: R,
    context?: any
): R
reduce<R>(reducer: (reduction: T | R, value: T, key: number, iter: this) => R): R

继承自

Collection#reduce

见

Array#reduce

如果initialReduction未提供，那么将会使用集合第一个元素。

reduceRight()

逆向地缩减集合的值（从结尾开始）。

reduceRight<R>(
    reducer: (reduction: R, value: T, key: number, iter: this) => R,
    initialReduction: R,
    context?: any
): R
reduceRight<R>(
    reducer: (reduction: T | R, value: T, key: number, iter: this) => R
): R

继承自

Collection#reduceRight

注意：与this.reverse().reduce()等效，为了与Array#reduceRight看齐而提供。

every()

当集合中所有元素predicate都判定为true时返回ture。

every(
    predicate: (value: T, key: number, iter: this) => boolean,
    context?: any
): boolean

继承自

Collection#every

some()

当集合中任意元素predicate判定为true时返回ture。

some(
    predicate: (value: T, key: number, iter: this) => boolean,
    context?: any
): boolean

继承自

Collection#some

join()

将值连接为字符串，并且在每两个值之间插入分割。默认分隔为","。

join(separator?: string): string

继承自

Collection#join

isEmpty()

当集合不包含值时返回true。

isEmpty(): boolean

继承自

Collection#isEmpty

对于惰性Seq，isEmpty会对他经常迭代来确定是否为空。至少会迭代一次。

count()

返回集合的大小。

count(): number
count(
    predicate: (value: T, key: number, iter: this) => boolean,
    context?: any
): number

继承自

Collection#count

不管此集合是否惰性地确定大小（某些Seq不能），这个方法将总是返回正确的大小。如果必要，他将会评估一个惰性的Seq。

如果predicate提供了，方法返回的数量将是集合中predicate返回true的元素个数。

countBy()

返回Seq.Keyed的数量，由grouper方法将值分组。

countBy<G>(
    grouper: (value: T, key: number, iter: this) => G,
    context?: any
): Map<G, number>

注意：这不是一个惰性操作。

对比

isSubset()

如果iter包含集合中所有元素则返回true。

isSubset(iter: Iterable<T>): boolean

继承自

Collection#isSubset

isSuperset()

如果集合包含iter中所有元素则返回true。

isSuperset(iter: Iterable<T>): boolean

继承自

Collection#isSuperset