Class Lists

读取、构建和重塑任意类型项的普通数组。位置从 0 开始：索引 0 是第一项。大多数方法接受一个默认开启的 clone 选项，它先深拷贝列表，因此输入永远不会被更改；关闭后，修改类方法就地作用于列表，对大数据更快。removeAllItems 总是清空传给它的列表。

Constructors

constructor

new Lists(): Bit.Lists
Returns Bit.Lists

add

addItemAtIndex

addItemAtIndex<T>(inputs: AddItemAtIndexDto<T>): T[]
在某位置插入一项；从该位置起的各项向后移一位。

示例：[10, 20, 30, 40] 在索引 2 插入 99 -> [10, 20, 99, 30, 40]
Type Parameters
- T
Parameters
- inputs: AddItemAtIndexDto<T>
  列表、项、索引以及是否复制
Returns T[]
插入该项后的列表
Example
```
const longer = bitbybit.lists.addItemAtIndex({ list: [10, 20, 30, 40], item: 99, index: 2, clone: true });
```
- Defined in bitbybit-docs.d.ts:54431

addItemAtIndexes

addItemAtIndexes<T>(inputs: AddItemAtIndexesDto<T>): T[]
在原列表的多个位置插入同一项。

示例：[10, 20, 30] 在索引 [0, 2] 插入 99 -> [99, 10, 20, 99, 30]
Type Parameters
- T
Parameters
- inputs: AddItemAtIndexesDto<T>
  列表、项、索引以及是否复制
Returns T[]
在每个索引处插入该项后的列表
Example
```
const marked = bitbybit.lists.addItemAtIndexes({ list: [10, 20, 30], item: 99, indexes: [0, 2], clone: true });
```
- Defined in bitbybit-docs.d.ts:54446

addItemsAtIndexes

addItemsAtIndexes<T>(inputs: AddItemsAtIndexesDto<T>): T[]
插入多项，第一项在第一个索引处，第二项在第二个索引处，依此类推，全部按原列表计数。

索引必须按升序排列，且每项必须有一个索引，否则抛出错误。示例：[10, 20, 30] 在索引 [1, 2] 插入项 [88, 99] -> [10, 88, 20, 99, 30]
Type Parameters
- T
Parameters
- inputs: AddItemsAtIndexesDto<T>
  列表、项、每项一个索引以及是否复制
Returns T[]
插入这些项后的列表
Example
```
const merged = bitbybit.lists.addItemsAtIndexes({ list: [10, 20, 30], items: [88, 99], indexes: [1, 2], clone: true });
```
- Defined in bitbybit-docs.d.ts:54463

addItem

addItem<T>(inputs: AddItemDto<T>): T[]
在列表末尾添加一项。

示例：[10, 20, 30] 添加 40 -> [10, 20, 30, 40]
Type Parameters
- T
Parameters
- inputs: AddItemDto<T>
  列表、项以及是否复制
Returns T[]
末尾添加该项后的列表
Example
```
const longer = bitbybit.lists.addItem({ list: [10, 20, 30], item: 40, clone: true });
```
- Defined in bitbybit-docs.d.ts:54626

prependItem

prependItem<T>(inputs: AddItemDto<T>): T[]
在列表开头添加一项。

示例：[10, 20, 30] 前置 5 -> [5, 10, 20, 30]
Type Parameters
- T
Parameters
- inputs: AddItemDto<T>
  列表、项以及是否复制
Returns T[]
开头添加该项后的列表
Example
```
const longer = bitbybit.lists.prependItem({ list: [10, 20, 30], item: 5, clone: true });
```
- Defined in bitbybit-docs.d.ts:54641

addItemFirstLast

addItemFirstLast<T>(inputs: AddItemFirstLastDto<T>): T[]
按选择在列表开头或末尾添加一项。

示例：[10, 20, 30] 在开头添加 5 -> [5, 10, 20, 30]；在末尾 -> [10, 20, 30, 5]
Type Parameters
- T
Parameters
- inputs: AddItemFirstLastDto<T>
  列表、项、位置以及是否复制
Returns T[]
添加该项后的列表
Example
```
const longer = bitbybit.lists.addItemFirstLast({ list: [10, 20, 30], item: 5, position: Bit.Inputs.Lists.firstLastEnum.first, clone: true });
```
- Defined in bitbybit-docs.d.ts:54656

concatenate

concatenate<T>(inputs: ConcatenateDto<T>): T[]
将多个列表首尾相接连成一个。

示例：[[1, 2], [3, 4], [5, 6]] -> [1, 2, 3, 4, 5, 6]
Type Parameters
- T
Parameters
- inputs: ConcatenateDto<T>
  要连接的列表以及是否复制
Returns T[]
包含所有项的一个列表
Example
```
const all = bitbybit.lists.concatenate({ lists: [[1, 2], [3, 4], [5, 6]], clone: true });
```
- Defined in bitbybit-docs.d.ts:54671

create

createEmptyList

createEmptyList(): []
创建一个空的新列表。

示例：-> []

Returns []
空列表
- Defined in bitbybit-docs.d.ts:54681

repeat

repeat<T>(inputs: MultiplyItemDto<T>): T[]
创建一个将同一项重复若干次的列表。

示例：5 重复三次 -> [5, 5, 5]
Type Parameters
- T
Parameters
- inputs: MultiplyItemDto<T>
  项和重复次数
Returns T[]
重复项的列表
Example
```
const fives = bitbybit.lists.repeat({ item: 5, times: 3 });
```
- Defined in bitbybit-docs.d.ts:54696

repeatInPattern

repeatInPattern<T>(inputs: RepeatInPatternDto<T>): T[]
反复重复一个项模式，直到列表达到给定长度。

示例：[1, 2, 3] 到长度 7 -> [1, 2, 3, 1, 2, 3, 1]
Type Parameters
- T
Parameters
- inputs: RepeatInPatternDto<T>
  模式、要达到的长度以及是否复制
Returns T[]
重复后的模式，截取到指定长度
Example
```
const cycle = bitbybit.lists.repeatInPattern({ list: [1, 2, 3], lengthLimit: 7, clone: true });
```
- Defined in bitbybit-docs.d.ts:54711

edit

reverse

reverse<T>(inputs: ListCloneDto<T>): T[]
反转各项的顺序。

示例：[1, 2, 3, 4, 5] -> [5, 4, 3, 2, 1]
Type Parameters
- T
Parameters
- inputs: ListCloneDto<T>
  列表以及是否先复制
Returns T[]
反转后的列表
- Defined in bitbybit-docs.d.ts:54318

shuffle

shuffle<T>(inputs: ListCloneDto<T>): T[]
将各项随机排序，每次调用都不同。

示例：[1, 2, 3, 4, 5] -> 可能为 [3, 1, 5, 2, 4]
Type Parameters
- T
Parameters
- inputs: ListCloneDto<T>
  列表以及是否先复制
Returns T[]
打乱后的列表
- Defined in bitbybit-docs.d.ts:54329

flipLists

flipLists<T>(inputs: ListCloneDto<T[]>): T[][]
将列表的列表翻转过来：行变成列，列变成行。

所有内部列表的长度必须相同。示例：[[0, 1, 2], [3, 4, 5]] -> [[0, 3], [1, 4], [2, 5]]
Type Parameters
- T
Parameters
- inputs: ListCloneDto<T[]>
  列表的列表以及是否先复制
Returns T[][]
转置后的列表的列表
Example
```
const columns = bitbybit.lists.flipLists({ list: [[0, 1, 2], [3, 4, 5]], clone: true });
```
- Defined in bitbybit-docs.d.ts:54345

groupNth

groupNth<T>(inputs: GroupListDto<T>): T[][]
将列表分成每组 n 项的若干组。

末尾剩余的项被丢弃，除非打开 keepRemainder，它会将它们添加为较短的最后一组。示例：[0, 1, 2, 3, 4, 5, 6, 7, 8] 每组 3 项 -> [[0, 1, 2], [3, 4, 5], [6, 7, 8]]
Type Parameters
- T
Parameters
- inputs: GroupListDto<T>
  列表、组大小以及是否保留不完整的最后一组
Returns T[][]
各组，按顺序排列
Example
```
const pairs = bitbybit.lists.groupNth({ list: [0, 1, 2, 3, 4], nrElements: 2, keepRemainder: true });
```
- Defined in bitbybit-docs.d.ts:54362

get

getItem

getItem<T>(inputs: ListItemDto<T>): T
读取列表中某位置的项，从 0 开始计数。

超出列表的索引会抛出错误。示例：[10, 20, 30, 40] 索引 2 -> 30
Type Parameters
- T
Parameters
- inputs: ListItemDto<T>
  列表、索引以及是否复制该项
Returns T
该索引处的项
Example
```
const third = bitbybit.lists.getItem({ list: [10, 20, 30, 40], index: 2, clone: true });
```
- Defined in bitbybit-docs.d.ts:54189

getFirstItem

getFirstItem<T>(inputs: ListCloneDto<T>): T
读取列表的第一项。

示例：[10, 20, 30, 40] -> 10
Type Parameters
- T
Parameters
- inputs: ListCloneDto<T>
  列表以及是否复制该项
Returns T
第一项
- Defined in bitbybit-docs.d.ts:54200

getLastItem

getLastItem<T>(inputs: ListCloneDto<T>): T
读取列表的最后一项。

示例：[10, 20, 30, 40] -> 40
Type Parameters
- T
Parameters
- inputs: ListCloneDto<T>
  列表以及是否复制该项
Returns T
最后一项
- Defined in bitbybit-docs.d.ts:54211

randomGetThreshold

randomGetThreshold<T>(inputs: RandomThresholdDto<T>): T[]
以给定概率保留列表的每一项并丢弃其余项，因此每次调用的结果都不同。

示例：[1, 2, 3, 4, 5]，阈值 0.5 -> 可能为 [1, 3, 5]
Type Parameters
- T
Parameters
- inputs: RandomThresholdDto<T>
  列表、保留某项的概率（0 到 1）以及是否复制
Returns T[]
被保留的项，保持原有顺序
Example
```
const some = bitbybit.lists.randomGetThreshold({ list: [1, 2, 3, 4, 5], threshold: 0.5, clone: true });
```
- Defined in bitbybit-docs.d.ts:54227

getSubList

getSubList<T>(inputs: SubListDto<T>): T[]
截取从起始索引到结束索引（不含）的项。

示例：[10, 20, 30, 40, 50] 从 1 到 4 -> [20, 30, 40]
Type Parameters
- T
Parameters
- inputs: SubListDto<T>
  列表、起始和结束索引以及是否复制
Returns T[]
该范围内的项
Example
```
const middle = bitbybit.lists.getSubList({ list: [10, 20, 30, 40, 50], indexStart: 1, indexEnd: 4, clone: true });
```
- Defined in bitbybit-docs.d.ts:54242

getNthItem

getNthItem<T>(inputs: GetNthItemDto<T>): T[]
从偏移处开始，保留每第 n 项。

示例：[0, 1, 2, 3, 4, 5, 6, 7, 8]，nth 3，偏移 0 -> [0, 3, 6]；nth 2，偏移 1 -> [1, 3, 5, 7]
Type Parameters
- T
Parameters
- inputs: GetNthItemDto<T>
  列表、步长、起始偏移以及是否复制
Returns T[]
每第 n 项，按顺序排列
Example
```
const everyThird = bitbybit.lists.getNthItem({ list: [0, 1, 2, 3, 4, 5, 6, 7, 8], nth: 3, offset: 0, clone: true });
```
- Defined in bitbybit-docs.d.ts:54258

getByPattern

getByPattern<T>(inputs: GetByPatternDto<T>): T[]
保留重复的 true/false 模式为 true 处的项，并丢弃其他项。

模式用完时从头重新开始。示例：[0, 1, 2, 3, 4, 5]，模式 [true, true, false] -> [0, 1, 3, 4]
Type Parameters
- T
Parameters
- inputs: GetByPatternDto<T>
  列表和模式
Returns T[]
模式保留的项，按顺序排列
Example
```
const kept = bitbybit.lists.getByPattern({ list: [0, 1, 2, 3, 4, 5], pattern: [true, true, false] });
```
- Defined in bitbybit-docs.d.ts:54274

mergeElementsOfLists

mergeElementsOfLists<T>(inputs: MergeElementsOfLists<T[]>): T[]
按位置重新分组嵌套列表：每个列表的第一项放在一起，然后是第二项，依此类推。

level 指定先在每个列表内部展平多少层嵌套；0 按原样重新分组。示例：[[0, 1, 2], [3, 4, 5]]，level 0 -> [[0, 3], [1, 4], [2, 5]]
Type Parameters
- T
Parameters
- inputs: MergeElementsOfLists<T[]>
  列表和进行重新分组的深度
Returns T[]
重新分组后的列表
Example
```
const columns = bitbybit.lists.mergeElementsOfLists({ lists: [[0, 1, 2], [3, 4, 5]], level: 0 });
```
- Defined in bitbybit-docs.d.ts:54292

getLongestListLength

getLongestListLength<T>(inputs: GetLongestListLength<T[]>): number
测量多个列表中最长的一个。

示例：[[1, 2], [3, 4, 5, 6], [7]] -> 4
Type Parameters
- T
Parameters
- inputs: GetLongestListLength<T[]>
  要测量的列表
Returns number
最长列表的长度
Example
```
const longest = bitbybit.lists.getLongestListLength({ lists: [[1, 2], [3, 4, 5, 6], [7]] });
```
- Defined in bitbybit-docs.d.ts:54307

includes

includes<T>(inputs: IncludesDto<T>): boolean
判断某项是否在列表中。

各项按同一性比较，因此只有当完全相同的对象在列表中时才能找到该对象。示例：[10, 20, 30, 40] 包含 30 -> true，包含 50 -> false
Type Parameters
- T
Parameters
- inputs: IncludesDto<T>
  列表和要查找的项
Returns boolean
当该项在列表中时为 true
Example
```
const found = bitbybit.lists.includes({ list: [10, 20, 30, 40], item: 30 });
```
- Defined in bitbybit-docs.d.ts:54379

findIndex

findIndex<T>(inputs: IncludesDto<T>): number
找出某项第一次出现的位置，不在列表中时为 -1。

示例：[10, 20, 30, 20, 40] 查找 20 -> 1，查找 50 -> -1
Type Parameters
- T
Parameters
- inputs: IncludesDto<T>
  列表和要查找的项
Returns number
从 0 开始的索引，或 -1
Example
```
const where = bitbybit.lists.findIndex({ list: [10, 20, 30, 20, 40], item: 20 });
```
- Defined in bitbybit-docs.d.ts:54394

getListDepth

getListDepth(inputs: ListCloneDto<[]>): number
测量列表内部列表嵌套的深度。

示例：[1, 2, 3] -> 1，[[1, 2], [3, 4]] -> 2，[[[1]]] -> 3
Parameters
- inputs: ListCloneDto<[]>
  列表
Returns number
嵌套层数
- Defined in bitbybit-docs.d.ts:54405

listLength

listLength<T>(inputs: ListCloneDto<T>): number
统计列表中的项数。

示例：[10, 20, 30, 40, 50] -> 5，[] -> 0
Type Parameters
- T
Parameters
- inputs: ListCloneDto<T>
  列表
Returns number
项的数量
- Defined in bitbybit-docs.d.ts:54416

remove

removeItemAtIndex

removeItemAtIndex<T>(inputs: RemoveItemAtIndexDto<T>): T[]
移除某位置的项。

示例：[10, 20, 30, 40, 50] 移除索引 2 -> [10, 20, 40, 50]
Type Parameters
- T
Parameters
- inputs: RemoveItemAtIndexDto<T>
  列表、索引以及是否复制
Returns T[]
去掉该项后的列表
Example
```
const shorter = bitbybit.lists.removeItemAtIndex({ list: [10, 20, 30, 40, 50], index: 2, clone: true });
```
- Defined in bitbybit-docs.d.ts:54478

removeFirstItem

removeFirstItem<T>(inputs: ListCloneDto<T>): T[]
移除第一项。

示例：[10, 20, 30, 40] -> [20, 30, 40]
Type Parameters
- T
Parameters
- inputs: ListCloneDto<T>
  列表以及是否先复制
Returns T[]
去掉第一项后的列表
- Defined in bitbybit-docs.d.ts:54489

removeLastItem

removeLastItem<T>(inputs: ListCloneDto<T>): T[]
移除最后一项。

示例：[10, 20, 30, 40] -> [10, 20, 30]
Type Parameters
- T
Parameters
- inputs: ListCloneDto<T>
  列表以及是否先复制
Returns T[]
去掉最后一项后的列表
- Defined in bitbybit-docs.d.ts:54500

removeItemAtIndexFromEnd

removeItemAtIndexFromEnd<T>(inputs: RemoveItemAtIndexDto<T>): T[]
移除从末尾计数的某项：索引 0 是最后一项，1 是它前面的一项。

示例：[10, 20, 30, 40, 50] 从末尾移除索引 1 -> [10, 20, 30, 50]
Type Parameters
- T
Parameters
- inputs: RemoveItemAtIndexDto<T>
  列表、从末尾算起的索引以及是否复制
Returns T[]
去掉该项后的列表
Example
```
const shorter = bitbybit.lists.removeItemAtIndexFromEnd({ list: [10, 20, 30, 40, 50], index: 1, clone: true });
```
- Defined in bitbybit-docs.d.ts:54515

removeItemsAtIndexes

removeItemsAtIndexes<T>(inputs: RemoveItemsAtIndexesDto<T>): T[]
移除多个位置的项，全部按原列表计数。

示例：[10, 20, 30, 40, 50] 移除索引 [1, 3] -> [10, 30, 50]
Type Parameters
- T
Parameters
- inputs: RemoveItemsAtIndexesDto<T>
  列表、索引以及是否复制
Returns T[]
去掉这些项后的列表
Example
```
const kept = bitbybit.lists.removeItemsAtIndexes({ list: [10, 20, 30, 40, 50], indexes: [1, 3], clone: true });
```
- Defined in bitbybit-docs.d.ts:54530

removeAllItems

removeAllItems<T>(inputs: ListDto<T>): T[]
就地清空给定的列表：返回同一个数组，其中没有任何项。

示例：[10, 20, 30, 40] -> []
Type Parameters
- T
Parameters
- inputs: ListDto<T>
  要清空的列表
Returns T[]
同一个列表，现已清空
- Defined in bitbybit-docs.d.ts:54541

removeNthItem

removeNthItem<T>(inputs: RemoveNthItemDto<T>): T[]
从偏移处开始，移除每第 n 项。

示例：[0, 1, 2, 3, 4, 5, 6, 7, 8]，nth 3，偏移 0 -> [1, 2, 4, 5, 7, 8]
Type Parameters
- T
Parameters
- inputs: RemoveNthItemDto<T>
  列表、步长、起始偏移以及是否复制
Returns T[]
去掉每第 n 项后的列表
Example
```
const thinned = bitbybit.lists.removeNthItem({ list: [0, 1, 2, 3, 4, 5, 6, 7, 8], nth: 3, offset: 0, clone: true });
```
- Defined in bitbybit-docs.d.ts:54556

randomRemoveThreshold

randomRemoveThreshold<T>(inputs: RandomThresholdDto<T>): T[]
以给定概率丢弃列表的每一项并保留其余项，因此每次调用的结果都不同。

示例：[1, 2, 3, 4, 5]，阈值 0.5 -> 可能为 [2, 4]
Type Parameters
- T
Parameters
- inputs: RandomThresholdDto<T>
  列表、舍弃某项的概率（0 到 1）以及是否复制
Returns T[]
留存下来的项，保持原有顺序
Example
```
const some = bitbybit.lists.randomRemoveThreshold({ list: [1, 2, 3, 4, 5], threshold: 0.5, clone: true });
```
- Defined in bitbybit-docs.d.ts:54572

removeDuplicateNumbers

removeDuplicateNumbers(inputs: RemoveDuplicatesDto<number>): number[]
移除重复的数值，保留各自的第一次出现。

示例：[1, 2, 3, 2, 4, 3, 5] -> [1, 2, 3, 4, 5]
Parameters
- inputs: RemoveDuplicatesDto<number>
  数值以及是否复制
Returns number[]
去除重复后的数值，保持原有顺序
- Defined in bitbybit-docs.d.ts:54583

removeDuplicateNumbersTolerance

removeDuplicateNumbersTolerance(
inputs: RemoveDuplicatesToleranceDto<number>,
): number[]
移除与已保留数值相差在容差以内的数值，因此仅因浮点噪声而不同的值算作相同。

示例：[1.0, 1.001, 2.0, 2.002, 3.0]，容差 0.01 -> [1.0, 2.0, 3.0]
Parameters
- inputs: RemoveDuplicatesToleranceDto<number>
  数值、容差以及是否复制
Returns number[]
去除近似重复后的数值，保持原有顺序
Example
```
const distinct = bitbybit.lists.removeDuplicateNumbersTolerance({ list: [1.0, 1.001, 2.0], tolerance: 0.01, clone: true });
```
- Defined in bitbybit-docs.d.ts:54599

removeDuplicates

removeDuplicates<T>(inputs: RemoveDuplicatesDto<T>): T[]
移除任何种类的重复项，保留各自的第一次出现。

各项按同一性比较，因此两个看起来相等的对象都会保留。示例：['a', 'b', 'c', 'a', 'd', 'b'] -> ['a', 'b', 'c', 'd']
Type Parameters
- T
Parameters
- inputs: RemoveDuplicatesDto<T>
  列表以及是否复制
Returns T[]
去除重复后的列表，保持原有顺序
- Defined in bitbybit-docs.d.ts:54611

sorting

sortNumber

sortNumber(inputs: SortDto<number>): number[]
将数值从小到大或从大到小排序。

示例：[5, 2, 8, 1, 9] 升序 -> [1, 2, 5, 8, 9]；降序 -> [9, 8, 5, 2, 1]
Parameters
- inputs: SortDto<number>
  数值、方向以及是否复制
Returns number[]
排序后的数值
Example
```
const sorted = bitbybit.lists.sortNumber({ list: [5, 2, 8, 1, 9], orderAsc: true, clone: true });
```
- Defined in bitbybit-docs.d.ts:54726

sortTexts

sortTexts(inputs: SortDto<string>): string[]
按字母顺序从 A 到 Z 或从 Z 到 A 排序文本。

示例：['dog', 'apple', 'cat'] 升序 -> ['apple', 'cat', 'dog']
Parameters
- inputs: SortDto<string>
  文本、方向以及是否复制
Returns string[]
排序后的文本
Example
```
const sorted = bitbybit.lists.sortTexts({ list: ["dog", "apple", "cat"], orderAsc: true, clone: true });
```
- Defined in bitbybit-docs.d.ts:54741

sortByPropValue

sortByPropValue(inputs: SortJsonDto<any>): any[]
按对象某个属性中保存的数值对对象排序。

示例：[{age: 30}, {age: 20}, {age: 25}] 按 'age' 升序 -> [{age: 20}, {age: 25}, {age: 30}]
Parameters
- inputs: SortJsonDto<any>
  对象、排序依据的属性、方向以及是否复制
Returns any[]
排序后的对象
Example
```
const byAge = bitbybit.lists.sortByPropValue({ list: [{ age: 30 }, { age: 20 }], property: "age", orderAsc: true, clone: true });
```
- Defined in bitbybit-docs.d.ts:54757

transform

interleave

interleave<T>(inputs: InterleaveDto<T>): T[]
依次取每个列表的第一项，然后是每个列表的第二项，依此类推，将多个列表交织成一个。

较短的列表用完后即退出。空的列表的列表会抛出错误。示例：[[0, 1, 2], [3, 4, 5]] -> [0, 3, 1, 4, 2, 5]
Type Parameters
- T
Parameters
- inputs: InterleaveDto<T>
  要交织在一起的列表以及是否复制
Returns T[]
各项交替排列的一个列表
Example
```
const woven = bitbybit.lists.interleave({ lists: [[0, 1, 2], [3, 4, 5]], clone: true });
```
- Defined in bitbybit-docs.d.ts:54774

Class Lists

Index

Constructors

add

create

edit

get

remove

sorting

transform

Constructors

constructor

Returns Bit.Lists

add

addItemAtIndex

Type Parameters

Parameters

Returns T[]

Example

addItemAtIndexes

Type Parameters

Parameters

Returns T[]

Example

addItemsAtIndexes

Type Parameters

Parameters

Returns T[]

Example

addItem

Type Parameters

Parameters

Returns T[]

Example

prependItem

Type Parameters

Parameters

Returns T[]

Example

addItemFirstLast

Type Parameters

Parameters

Returns T[]

Example

concatenate

Type Parameters

Parameters

Returns T[]

Example

create

createEmptyList

Returns []

repeat

Type Parameters

Parameters

Returns T[]

Example

repeatInPattern

Type Parameters

Parameters

Returns T[]

Example

edit

reverse

Type Parameters

Parameters

Returns T[]

shuffle

Type Parameters

Parameters

Returns T[]

flipLists

Type Parameters

Parameters

Returns T[][]

Example

groupNth

Type Parameters

Parameters

Returns T[][]