Teal TealUI

数组扩展util/array

提供 JavaScript 内置对象 Array 的扩展接口。

API

函数 描述
⮞ range(start, end, ...)(start:number, end:number, step?:number):number[]

创建一个等差数列组成的数组。

参数 类型 描述 默认值
start* number —
end* number —
step number 1

返回值

类型：number[]

返回一个新数组。

示例

range(0, 6) // [0, 1, 2, 3, 4, 5]
range(2, 11, 3) // [2, 5, 8]

创建一个等差数列组成的数组。
⮞ pushIf(arr, item)<T>(arr:T[], item:T):boolean

如果数组中不存在项则添加到数组末尾。

泛型参数 约束类型 默认类型
T — —
参数 类型 描述 默认值
arr* T[] —
item* T —

返回值

类型：boolean

如果已添加到数组则返回 true，否则返回 false。

示例

pushIf(1, 9, 0], 1) // 数组变成 [1, 9, 0]
pushIf([1, 9, 0], 2) // 数组变成 [1, 9, 0, 2]

如果数组中不存在项则添加到数组末尾。
⮞ insert(arr, index, item)<T>(arr:T[], index:number, item:T):void

在数组的指定索引插入项。

泛型参数 约束类型 默认类型
T — —
参数 类型 描述 默认值
arr* T[] —
index* number —
item* T —

返回值

类型：void

示例

insert(["I", "you"], 1, "love") // 数组变成 ["I", "love", "you"]

在数组的指定索引插入项。
⮞ remove(arr, item, ...)<T>(arr:T[], item:T, startIndex?:number):number

删除数组中指定的项。如果有多个匹配则只删除第一项。

泛型参数 约束类型 默认类型
T — —
参数 类型 描述 默认值
arr* T[] —
item* T —
startIndex number —

返回值

类型：number

返回被删除的项在原数组中的索引。如果数组中找不到指定的项则返回 -1。

示例

remove([1, 9, 9, 0], 9) // 1, 数组变成 [1, 9, 0]
while(remove(arr, "wow") >= 0) // 删除所有 "wow"。

删除数组中指定的项。如果有多个匹配则只删除第一项。
⮞ removeAll(arr, item, ...)<T>(arr:T[], item:T, startIndex?:number):void

删除数组中指定的项。如果有多个匹配则全部删除。

泛型参数 约束类型 默认类型
T — —
参数 类型 描述 默认值
arr* T[] —
item* T —
startIndex number —

返回值

类型：void

示例

removeAll([1, 9, 9, 0], 9) // 数组变成 [1, 0]

删除数组中指定的项。如果有多个匹配则全部删除。
⮞ clean(arr)<T>(arr:T[]):void

删除数组中转为布尔值后为 false 的项。

泛型参数 约束类型 默认类型
T — —
参数 类型 描述 默认值
arr* T[] —

返回值

类型：void

示例

clean(["", false, 0, undefined, null, {}]) // 数组变成 [{}]

删除数组中转为布尔值后为 false 的项。
⮞ clear(arr)<T>(arr:T[]):void

清空数组的所有项。

泛型参数 约束类型 默认类型
T — —
参数 类型 描述 默认值
arr* T[] —

返回值

类型：void

示例

clear([1, 2]) // 数组变成 []

清空数组的所有项。
⮞ swap(arr, x, y)<T>(arr:T[], x:number, y:number):void

交换数组中的两个项。

泛型参数 约束类型 默认类型
T — —
参数 类型 描述 默认值
arr* T[] —
x* number —
y* number —

返回值

类型：void

示例

swap([1, 2, 3], 1, 2)

交换数组中的两个项。
⮞ sortBy(arr, ...)<T>(arr:T[], ...keys:(function | (keyof T))[]):void

根据指定的规则排序。

泛型参数 约束类型 默认类型
T — —
参数 类型 描述 默认值
arr* T[] —
keys (((item: T) => any) | (keyof T))[] —

返回值

类型：void

示例

sortBy([{ "user": "fred" }, { "user": "bred" }], o => o.user) // [{ "user": "bred" }, { "user": "fred" }]
sortBy([{ "user": "fred" }, { "user": "bred" }], "user") // [{ "user": "bred" }, { "user": "fred" }]

根据指定的规则排序。
⮞ sortByDesc(arr, ...)<T>(arr:T[], ...keys:(function | (keyof T))[]):T[]

根据指定的规则倒排。

泛型参数 约束类型 默认类型
T — —
参数 类型 描述 默认值
arr* T[] —
keys (((item: T) => any) | (keyof T))[] —

返回值

类型：T[]

示例

sortByDesc([{ "user": "bred" }, { "user": "fred" }], o => o.user) // [{ "user": "fred" }, { "user": "bred" }]
sortByDesc([{ "user": "bred" }, { "user": "fred" }], "user") // [{ "user": "fred" }, { "user": "bred" }]

根据指定的规则倒排。
⮞ groupBy(arr, key)<T>(arr:T[], key:function | (keyof T)):(T[] & { key: any; })[]

将数组的项按指定规则分组。

泛型参数 约束类型 默认类型
T — —
参数 类型 描述 默认值
arr* T[] —
key* ((item: T) => any) | (keyof T) —

返回值

类型：(T[] & { key: any; })[]

示例

groupBy([{a: 1}, {a: 1}, {a: 2}], "a") // [{key: 1, length: 2, 0: {a: 1}, 1: {a: 1}}, {key: 2, length: 1, 0: {a: 1}}]

将数组的项按指定规则分组。
⮞ countBy(arr, key)<T>(arr:T[], key:function | (keyof T)):object

将数组的项按指定规则分组然后统计每个分组的项数。

泛型参数 约束类型 默认类型
T — —
参数 类型 描述 默认值
arr* T[] —
key* ((item: T) => any) | (keyof T) —

返回值

类型：{ [key: string]: number; }

示例

countBy([{a: 1}, {a: 1}, {a: 2}], "a") // {1: 2, 2: 1}

将数组的项按指定规则分组然后统计每个分组的项数。
⮞ split(arr, ...)<T>(arr:T[], count?:number, maxCount?:number):T[][]

将数组等分成多个子数组。

泛型参数 约束类型 默认类型
T — —
参数 类型 描述 默认值
arr* T[] —
count number 1
maxCount number —

返回值

类型：T[][]

返回一个二维数组。

示例

split([1, 2, 3, 4, 5], 2) // [[1, 2], [3, 4], [5]]

将数组等分成多个子数组。
⮞ shuffle(arr)<T>(arr:T[]):void

将数组中的项随机打乱。

泛型参数 约束类型 默认类型
T — —
参数 类型 描述 默认值
arr* T[] —

返回值

类型：void

示例

shuffle([1, 2, 3])

将数组中的项随机打乱。
⮞ random(arr)<T>(arr:T[]):T

随机获取数组中的任一项。

泛型参数 约束类型 默认类型
T — —
参数 类型 描述 默认值
arr* T[] —

返回值

类型：T

返回某一项。如果数组为空则返回 undefined。

示例

random([1, 2, 3])

随机获取数组中的任一项。
⮞ item(arr, index)<T>(arr:T[], index:number):T

获取数组中指定索引的项。

泛型参数 约束类型 默认类型
T — —
参数 类型 描述 默认值
arr* T[] —
index* number —

返回值

类型：T

返回指定索引的项。

示例

item(["a", "b"], -1) // "b"

获取数组中指定索引的项。
⮞ pick(arr)<T>(arr:T[]):T

获取数组中第一个不为空的项。

泛型参数 约束类型 默认类型
T — —
参数 类型 描述 默认值
arr* T[] —

返回值

类型：T

返回第一个不为空的项，如果所有项都为空则返回 undefined。

示例

pick([undefined, null, 1, 2]) // 1

获取数组中第一个不为空的项。
⮞ count(arr, item, ...)<T>(arr:T[], item:T, startIndex?:number, endIndex?:number):number

计算指定项在数组中出现的次数。

泛型参数 约束类型 默认类型
T — —
参数 类型 描述 默认值
arr* T[] —
item* T —
startIndex number 0
endIndex number arr.length

返回值

类型：number

返回项出现的次数。

示例

count(["a", "b"], "a") // 1

计算指定项在数组中出现的次数。
⮞ isUnique(arr)<T>(arr:T[]):boolean

判断数组中是否存在重复项。

泛型参数 约束类型 默认类型
T — —
参数 类型 描述 默认值
arr* T[] —

返回值

类型：boolean

若数组中存在重复项则返回 true，否则返回 false。

示例

isUnique([1, 9, 0]) // true
isUnique([1, 9, 9, 0]) // false

判断数组中是否存在重复项。
⮞ unique(arr)<T>(arr:T[]):T[]

删除数组中的重复项并返回新数组。

泛型参数 约束类型 默认类型
T — —
参数 类型 描述 默认值
arr* T[] —

返回值

类型：T[]

返回过滤后的新数组。

示例

[1, 9, 9, 0].unique() // [1, 9, 0]

删除数组中的重复项并返回新数组。
⮞ flatten(arr)(arr:any[]):any[]

将多维数组合并为一维数组。

参数 类型 描述 默认值
arr* any[] —

返回值

类型：any[]

返回新数组。

示例

flatten([[1, 2], [[[3]]]]) // [1, 2, 3]

将多维数组合并为一维数组。
⮞ sub(arr, other)<T>(arr:T[], other:T[]):T[]

从数组中删除另一个数组的所有项，返回剩下的项组成的新数组。

泛型参数 约束类型 默认类型
T — —
参数 类型 描述 默认值
arr* T[] —
other* T[] —

返回值

类型：T[]

返回新数组。

示例

sub([1, 2], [1]) // [2]

从数组中删除另一个数组的所有项，返回剩下的项组成的新数组。
⮞ union(...)<T>(...arrs:T[][]):T[]

计算所有数组的并集。

泛型参数 约束类型 默认类型
T — —
参数 类型 描述 默认值
arrs T[][] —

返回值

类型：T[]

返回所有数组中出现过的元素组成的无重复项的新数组。

示例

union([1, 2], [1]) // [1, 2]

计算所有数组的并集。
⮞ intersect(...)<T>(...arrs:T[][]):T[]

计算所有数组的交集。

泛型参数 约束类型 默认类型
T — —
参数 类型 描述 默认值
arrs T[][] —

返回值

类型：T[]

返回所有数组中公共元素组成的无重复项的新数组。

示例

intersect([1, 2, 3], [101, 2, 1, 10], [2, 1]) // [1, 2]

计算所有数组的交集。
⮞ permute(arr)<T>(arr:T[]):T[][]

计算数组的全排列结果。

泛型参数 约束类型 默认类型
T — —
参数 类型 描述 默认值
arr* T[] —

返回值

类型：T[][]

返回一个新数组，其每一项都是一种排列方式。

示例

permute([1, 2, 3]) // [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]

计算数组的全排列结果。
⮞ select(arr, key)<T, R>(arr:T[], key:function | (keyof T)):R[]

根据指定的规则选择项。

泛型参数 约束类型 默认类型
T — —
R — —
参数 类型 描述 默认值
arr* T[] —
key* ((item: T) => R) | (keyof T) —

返回值

类型：R[]

返回选择的结果组成的新数组。

示例

select([{"user": "fred"}, {"banch": "bred"}], o => o.user) // ["fred"]
select([{"user": "fred"}, {"banch": "bred"}], "user") // ["fred"]

根据指定的规则选择项。
⮞ invoke(arr, fnName, ...)<T>(arr:T[], fnName:string, ...args:any[]):T[]

调用数组每一项的成员函数。

泛型参数 约束类型 默认类型
T — —
参数 类型 描述 默认值
arr* T[] —
fnName* string —
args any[] —

返回值

类型：T[]

返回所有调用结果组成的新数组。

示例

invoke(["Teal", "UI"], "length") // [4, 2]

调用数组每一项的成员函数。
⮞ associate(arr, keys)<T>(arr:T[], keys:string[]):object

将数组中的项分别和指定的键组合为对象。

泛型参数 约束类型 默认类型
T — —
参数 类型 描述 默认值
arr* T[] —
keys* string[] —

返回值

类型：{ [key: string]: T; }

返回数组和指定键组成的键值对。

示例

associate([1, 2], ["a", "b"]) // { a: 1, b: 2 }

将数组中的项分别和指定的键组合为对象。
⮞ binarySearch(arr, value, ...)<T>(arr:T[], value:T, compareFn?:function, start?:number, end?:number):number

在已排序的数组中二分查找指定的项。

泛型参数 约束类型 默认类型
T — —
参数 类型 描述 默认值
arr* T[] —
value* T —
compareFn (item1: T, item2: T) => any —
start number 0
end number arr.length

返回值

类型：number

示例

binarySearch([1, 2, 3, 4, 5], 3) // 2

在已排序的数组中二分查找指定的项。
⮞ min(arr)(arr:number[]):number

计算数组中所有项的最小值。

参数 类型 描述 默认值
arr* number[] —

返回值

类型：number

返回数组中所有项的最小值。如果数组为空则返回 Infinity。

示例

min([1, 2]) // 1

计算数组中所有项的最小值。
⮞ max(arr)(arr:number[]):number

计算数组中所有项的最大值。

参数 类型 描述 默认值
arr* number[] —

返回值

类型：number

返回数组中所有项的最大值。如果数组为空则返回 -Infinity。

示例

max([1, 2]) // 2

计算数组中所有项的最大值。
⮞ sum(arr)(arr:number[]):number

计算数组中所有项的和。

参数 类型 描述 默认值
arr* number[] —

返回值

类型：number

返回数组中所有数值的和。计算时将忽略非数字的项。如果数组为空则返回 0。

示例

sum([1, 2]) // 3

计算数组中所有项的和。
⮞ avg(arr)(arr:number[]):number

计算数组中所有项的算术平均值。

参数 类型 描述 默认值
arr* number[] —

返回值

类型：number

返回数组中所有数值的算术平均值。计算时将忽略非数字的项。如果数组为空则返回 0。

示例

avg([1, 2]) // 1.5

计算数组中所有项的算术平均值。