ZGG文档
搜索文档…
ZGG内置类型-数组
ZGG语言提供了强大的数组功能。数组,可以定义为有限个值的有序集合

数组的声明与访问

数组声明方法:
1
[item0, item1, ...]
Copied!
每个item是一个表达式,数组保存的是表达式计算后得到的值。下标从0开始
访问数组指定下标的元素的语法为:
1
arr[index]
Copied!

数组的运算

加法

若干个数组相加,将返回一个新的数组,其内容为各个参与相加的数组的依次拼接
1
zgg> [1, 2, 3] + [4, 5, 6] + [7, 8, 9]
2
[1, 2, 3, 4, 5, 6, 7, 8, 9]
Copied!

乘法

数组支持乘以一个大于等于0的整数,其作用为将其重复若干遍。如:
1
zgg> [1, 2, 3] * 3
2
[1, 2, 3, 1, 2, 3, 1, 2, 3]
3
zgg> [1, 2, 3] * 0
4
[]
Copied!
注:乘以0的时候,即重复0遍,必然返回空数组

数组推导式

ZGG支持通过类似Python的数组推导式生成新的数组。
以下是一些常见的数组推导式用法:
1
zgg> a := [1, 2, 3, 4, 5, 6]
2
[1, 2, 3, 4, 5, 6]
3
4
zgg> [item * item for item in a]
5
[1, 4, 9, 16, 25, 36]
6
7
zgg> [item * 2 for item in a if item % 2 == 0]
8
[4, 8, 12]
9
10
zgg> [v * 2 for v in 2..10] // 2..10在for..in里面相当于[2, 3, 4, 5, 6, 7, 8, 9, 10],但不需要创建一个临时数组,效率更高
11
[4, 6, 8, 10, 12, 14, 16, 18, 20]
12
13
zgg> [v * 2 for v in 2..<10] // 2..<10在for..in里面相当于[2, 3, 4, 5, 6, 7, 8, 9],但不需要创建一个临时数组,效率更高
14
[4, 6, 8, 10, 12, 14, 16, 18]
15
16
zgg> [v * 2 for v in 10] // for .. in 10是for .. in 0..<10的简化写法
17
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
Copied!

数组的内置方法

为了提高工作效率,ZGG内置了大量实用的数组方法
方法名
作用
map
filter
reduce
each
push
往数组末尾添加元素
slice
获取数组切片
sort
原地排序
join
将数组各元素依次拼接为一个字符串
toMap
将数组元素转为一个Map
toGroup
将数组元素按自定义key分组
chunk
将数组元素按顺序分组
find
查找数组中出现的第一个符合预期的元素,找不到则返回undefined
findIndex
查找数组中出现的第一个符合预期的元素的下标,找不到则返回-1
times
//

生成数组的内建函数

函数名
作用
seq(a, b)
返回从a到b的数组。如:seq(1, 5)返回[1, 2, 3, 4, 5]。更多用法请看下面的详解
具体用法见详解
具体用法见详解
具体用法见详解

函数详解

Array.map(mapper)

将数组每个元素根据mapper映射到指定形式,存放到新的数组中并返回。原数组内容不变
mapper支持多种不同类型:
mapper类型
映射结果
任意可执行对象
mapper(item, index)
Int或Str
item[mapper]

Examples:

1
zgg> [1, 2, 3].map(v => v * v)
2
[1, 4, 9]
3
zgg> [{x: 1}, {x: 2}, {x: 3}].map('x')
4
[1, 2, 3]
5
zgg> [{x: 1}, {x: 2}, {x: 3}].map('y')
6
[undefined, undefined, undefined]
7
zgg> [[1, 2, 3], [2, 3, 4], [3, 4, 5]].map(1)
8
[2, 3, 4]
Copied!

Array.filter(filterFunc)

将原数组将符合条件的元素,依次放在新数组并返回。
符合条件的定义是:filterFunc(item, index)返回一个真值。真值的定义请看条件判断章节

Examples:

1
zgg> seq(1, 10).filter(v => v % 2 == 0)
2
[2, 4, 6, 8, 10]
Copied!

Array.reduce(reducer, initialValue?)

reduce() 方法接收一个函数reducer作为累加器,数组中的每个值(从左到右)开始缩减,最终计算为一个值。
参数说明:
  • reducer: 格式为:func(total, currenetValue, currentIndex, thisArray)。如果不设reduce,默认会把各个元素相加返回(即为数组求和)
  • initialValue: 可选。传递给函数的初始total值
更多细节请看下面例子或参考Javascript里的表现。

Examples:

1
zgg> seq(1, 10).reduce() // 不传reducer,默认为求和
2
55
3
4
zgg> seq('a', 'g').reduce() // 字符串的求和,即依次拼接
5
abcdefg
6
7
zgg> seq(1, 10).reduce((total, cur) => total + cur)
8
55
9
10
zgg> seq(1, 10).reduce((total, cur) => total + cur ** 2)
11
385
12
13
zgg> seq(1, 10).reduce((total, cur) => total + cur ** 2, 0)
14
385
15
16
zgg> seq(1, 10).reduce((total, cur) => total + cur ** 2, 100)
17
485
18
19
zgg> // 当没有传入initialValue时,第一次执行的total为array[0],cur为array[1]
20
zgg> seq(1, 5).reduce((total, cur) => {
21
.... println('total is $total, cur is $cur')
22
.... return total + cur
23
.... })
24
total is 1, cur is 2
25
total is 3, cur is 3
26
total is 6, cur is 4
27
total is 10, cur is 5
28
15
29
30
zgg> // 当有传入initialValue时,第一次执行的total为initialValue,cur为array[0]
31
zgg> seq(1, 5).reduce((total, cur) => {
32
.... println('total is $total, cur is $cur')
33
.... return total + cur
34
.... }, 0)
35
total is 0, cur is 1
36
total is 1, cur is 2
37
total is 3, cur is 3
38
total is 6, cur is 4
39
total is 10, cur is 5
40
15
Copied!

Array.each(callback)

依次取数组元素,调用callback函数。以下两段代码时等价的:
1
arr.each(callback)
Copied!
1
for index, value in arr {
2
callback(value, index)
3
}
Copied!

Array.toMap(keyMapper?, valueMapper?)

根据数组内的元素,生成一个Object对象,其键名为数组元素被keyMapper映射后的结果,键值为元素被valueMapper映射后的结果。
注:
  • mapper的映射规则,请参考数组的map方法
  • keyMapper和valueMapper都可以缺省,缺省时映射结果为元素本身
  • 如果多个元素映射的键名相同,将保留最后一个元素映射的键值

Examples:

1
zgg> items := [{value} for value in 1..10]
2
[{value: 1}, {value: 2}, {value: 3}, {value: 4}, {value: 5}, {value: 6}, {value: 7}, {value: 8}, {value: 9}, {value: 10}]
3
4
zgg> items.toMap(item => item.value % 3)
5
{
6
1: {value: 10},
7
2: {value: 8},
8
0: {value: 9}
9
}
10
11
zgg> items.toMap(item => item.value % 3, 'value')
12
{1: 10, 2: 8, 0: 9}
13
14
zgg> items.toMap('value')
15
{
16
7: {value: 7},
17
9: {value: 9},
18
10: {value: 10},
19
1: {value: 1},
20
3: {value: 3},
21
6: {value: 6},
22
8: {value: 8},
23
2: {value: 2},
24
4: {value: 4},
25
5: {value: 5}
26
}
Copied!

Array.toGroup(keyMapper?, valueMapper?)

根据key分组。根据数组内的元素,生成一个Object对象,其键名为数组元素被keyMapper映射后的结果,键值为“所有映射到该键名的元素被valueMapper映射后的结果”的数组。
注:
  • mapper的映射规则,请参考数组的map方法
  • keyMapper和valueMapper都可以缺省,缺省时映射结果为元素本身
  • 同一分组元素顺序,为这些元素在原数组的顺序

Examples:

1
zgg> items := [{value} for value in 1..10]
2
[{value: 1}, {value: 2}, {value: 3}, {value: 4}, {value: 5}, {value: 6}, {value: 7}, {value: 8}, {value: 9}, {value: 10}]
3
4
zgg> items.toGroup(item => item.value % 3)
5
{
6
0: [{value: 3}, {value: 6}, {value: 9}],
7
1: [{value: 1}, {value: 4}, {value: 7}, {value: 10}],
8
2: [{value: 2}, {value: 5}, {value: 8}]
9
}
10
zgg> items.toGroup(item => item.value % 3, 'value')
11
{
12
0: [3, 6, 9],
13
1: [1, 4, 7, 10],
14
2: [2, 5, 8]
15
}
Copied!

Array.chunk(chunkSize)

将数据元素按固定大小分段

Examples:

1
zgg> seq(1, 10).chunk(4)
2
[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10]]
Copied!

Array.find(predict)

找到第一个符合predict的元素并返回。当找不到符合元素时返回undefined
符合条件的定义是:
  • predict若为可执行对象:predict(item)返回真值
  • 否则: item == predict

Examples:

1
zgg> seq(1, 10).find(4)
2
4
3
zgg> seq(1, 10).find(20)
4
undefined
Copied!

Array.findIndex(predict)

与find相似,区别在于findIndex返回的是元素的下标,找不到的时候返回-1

Examples:

1
zgg> seq(1, 10).findIndex(4)
2
3
3
zgg> seq(1, 10).findIndex(20)
4
-1
Copied!

func seq(a, b)

生成从a到b的数组。这里的a和b的类型不仅局限于Int,还支持所有实现了__next__协议和__eq__协议的对象。

func range(end)

Example:

1
zgg> range(5)
2
[0, 1, 2, 3, 4]
Copied!

func range(begin, end)

Example:

1
zgg> range(2, 5)
2
[2, 3, 4]
Copied!

func range(begin, end, step)

Example:

1
zgg> range(2, 10, 3)
2
[2, 5, 8]
Copied!