ZGG内置类型-数组

ZGG语言提供了强大的数组功能。数组，可以定义为有限个值的有序集合

数组的声明与访问

数组声明方法：

[item0, item1, ...]

每个item是一个表达式，数组保存的是表达式计算后得到的值。下标从0开始

访问数组指定下标的元素的语法为：

arr[index]

数组的运算

加法

若干个数组相加，将返回一个新的数组，其内容为各个参与相加的数组的依次拼接

zgg> [1, 2, 3] + [4, 5, 6] + [7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]

乘法

数组支持乘以一个大于等于0的整数，其作用为将其重复若干遍。如：

zgg> [1, 2, 3] * 3
[1, 2, 3, 1, 2, 3, 1, 2, 3]
zgg> [1, 2, 3] * 0
[]

注：乘以0的时候，即重复0遍，必然返回空数组

数组推导式

ZGG支持通过类似Python的数组推导式生成新的数组。

以下是一些常见的数组推导式用法：

zgg> a := [1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5, 6]

zgg> [item * item for item in a]
[1, 4, 9, 16, 25, 36]

zgg> [item * 2 for item in a if item % 2 == 0]
[4, 8, 12]

zgg> [v * 2 for v in 2..10] // 2..10在for..in里面相当于[2, 3, 4, 5, 6, 7, 8, 9, 10]，但不需要创建一个临时数组，效率更高
[4, 6, 8, 10, 12, 14, 16, 18, 20]

zgg> [v * 2 for v in 2..<10] // 2..<10在for..in里面相当于[2, 3, 4, 5, 6, 7, 8, 9]，但不需要创建一个临时数组，效率更高
[4, 6, 8, 10, 12, 14, 16, 18]

zgg> [v * 2 for v in 10]  // for .. in 10是for .. in 0..<10的简化写法
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

数组的内置方法

为了提高工作效率，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]。更多用法请看下面的详解
range(end)	具体用法见详解
range(begin, end)	具体用法见详解
range(begin, end, step)	具体用法见详解

函数详解

Array.map(mapper)

将数组每个元素根据mapper映射到指定形式，存放到新的数组中并返回。原数组内容不变

mapper支持多种不同类型：

mapper类型	映射结果
任意可执行对象	mapper(item, index)
Int或Str	item[mapper]

Examples:

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

Array.filter(filterFunc)

将原数组将符合条件的元素，依次放在新数组并返回。

符合条件的定义是：filterFunc(item, index)返回一个真值。真值的定义请看条件判断章节

Examples:

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

Array.reduce(reducer, initialValue?)

reduce() 方法接收一个函数reducer作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值。

参数说明：

• reducer: 格式为：func(total, currenetValue, currentIndex, thisArray)。如果不设reduce，默认会把各个元素相加返回（即为数组求和）

• initialValue: 可选。传递给函数的初始total值

更多细节请看下面例子或参考Javascript里的表现。

Examples:

zgg> seq(1, 10).reduce() // 不传reducer，默认为求和
55

zgg> seq('a', 'g').reduce() // 字符串的求和，即依次拼接
abcdefg

zgg> seq(1, 10).reduce((total, cur) => total + cur)
55

zgg> seq(1, 10).reduce((total, cur) => total + cur ** 2)
385

zgg> seq(1, 10).reduce((total, cur) => total + cur ** 2, 0)
385

zgg> seq(1, 10).reduce((total, cur) => total + cur ** 2, 100)
485

zgg> // 当没有传入initialValue时，第一次执行的total为array[0]，cur为array[1]
zgg> seq(1, 5).reduce((total, cur) => {
....   println('total is $total, cur is $cur')
....   return total + cur
.... })
total is 1, cur is 2
total is 3, cur is 3
total is 6, cur is 4
total is 10, cur is 5
15

zgg> // 当有传入initialValue时，第一次执行的total为initialValue，cur为array[0]
zgg> seq(1, 5).reduce((total, cur) => {
....   println('total is $total, cur is $cur')
....   return total + cur
.... }, 0)
total is 0, cur is 1
total is 1, cur is 2
total is 3, cur is 3
total is 6, cur is 4
total is 10, cur is 5
15

Array.each(callback)

依次取数组元素，调用callback函数。以下两段代码时等价的：

arr.each(callback)

与

for index, value in arr {
    callback(value, index)
}

Array.toMap(keyMapper?, valueMapper?)

根据数组内的元素，生成一个Object对象，其键名为数组元素被keyMapper映射后的结果，键值为元素被valueMapper映射后的结果。

注：

• mapper的映射规则，请参考数组的map方法

• keyMapper和valueMapper都可以缺省，缺省时映射结果为元素本身

• 如果多个元素映射的键名相同，将保留最后一个元素映射的键值

Examples:

zgg> items := [{value} for value in 1..10]
[{value: 1}, {value: 2}, {value: 3}, {value: 4}, {value: 5}, {value: 6}, {value: 7}, {value: 8}, {value: 9}, {value: 10}]

zgg> items.toMap(item => item.value % 3)
{
    1: {value: 10},
    2: {value: 8},
    0: {value: 9}
}

zgg> items.toMap(item => item.value % 3, 'value')
{1: 10, 2: 8, 0: 9}

zgg> items.toMap('value')
{
    7: {value: 7},
    9: {value: 9},
    10: {value: 10},
    1: {value: 1},
    3: {value: 3},
    6: {value: 6},
    8: {value: 8},
    2: {value: 2},
    4: {value: 4},
    5: {value: 5}
}

Array.toGroup(keyMapper?, valueMapper?)

根据key分组。根据数组内的元素，生成一个Object对象，其键名为数组元素被keyMapper映射后的结果，键值为“所有映射到该键名的元素被valueMapper映射后的结果”的数组。

注：

• mapper的映射规则，请参考数组的map方法

• keyMapper和valueMapper都可以缺省，缺省时映射结果为元素本身

• 同一分组元素顺序，为这些元素在原数组的顺序

Examples:

zgg> items := [{value} for value in 1..10]
[{value: 1}, {value: 2}, {value: 3}, {value: 4}, {value: 5}, {value: 6}, {value: 7}, {value: 8}, {value: 9}, {value: 10}]

zgg> items.toGroup(item => item.value % 3)
{
    0: [{value: 3}, {value: 6}, {value: 9}],
    1: [{value: 1}, {value: 4}, {value: 7}, {value: 10}],
    2: [{value: 2}, {value: 5}, {value: 8}]
}
zgg> items.toGroup(item => item.value % 3, 'value')
{
    0: [3, 6, 9],
    1: [1, 4, 7, 10],
    2: [2, 5, 8]
}

Array.chunk(chunkSize)

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

Examples:

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

Array.find(predict)

找到第一个符合predict的元素并返回。当找不到符合元素时返回undefined

符合条件的定义是：

• predict若为可执行对象：predict(item)返回真值

• 否则: item == predict

Examples:

zgg> seq(1, 10).find(4)
4
zgg> seq(1, 10).find(20)
undefined

Array.findIndex(predict)

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

Examples:

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

func seq(a, b)

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

func range(end)

Example:

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

func range(begin, end)

Example:

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

func range(begin, end, step)

Example:

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