数组

声明

不写长度的是动态数组，可以增删元素；写了长度的是静态数组，长度固定。

拼音

bl a = [11, 12, 32]                      // 动态数组，元素类型取第一个元素
bl b leixing [z32] = [11, 12, 32]        // 动态数组，显式元素类型
bl c leixing [z32; 5] = [1, 2, 3, 7, 8]  // 静态数组，长度 5

中文

变量 a = [11, 12, 32]                   // 动态数组，元素类型取第一个元素
变量 b 类型 [i32] = [11, 12, 32]        // 动态数组，显式元素类型
变量 c 类型 [i32; 5] = [1, 2, 3, 7, 8]  // 静态数组，长度 5

英文

var a = [11, 12, 32]                    // 动态数组，元素类型取第一个元素
var b type [i32] = [11, 12, 32]         // 动态数组，显式元素类型
var c type [i32; 5] = [1, 2, 3, 7, 8]   // 静态数组，长度 5

• 所有元素必须是同一类型
• 静态数组初始化必须写满长度
• 空数组必须写明类型：

拼音

bl a leixing [z64] = []   // ✓
bl b = []                 // ✗ 推断不出元素类型

中文

变量 a 类型 [i64] = []    // ✓
变量 b = []               // ✗ 推断不出元素类型

英文

var a type [i64] = []     // ✓
var b = []                // ✗ 推断不出元素类型

• 数组可以嵌套：

拼音

bl m leixing [[z64]] = [[1, 2], [3, 4]]
dayin(m[1][0])            // 3

中文

变量 m 类型 [[i64]] = [[1, 2], [3, 4]]
打印(m[1][0])             // 3

英文

var m type [[i64]] = [[1, 2], [3, 4]]
print(m[1][0])            // 3

下标访问

读写都用 a[i]，下标从 0 开始。越界会 panic，程序终止。

拼音

bl a = [10, 20, 30]
dayin(a[1])               // 20
a[1] = 99
dayin(a[5])               // panic: 数组下标越界: index=5, length=3

中文

变量 a = [10, 20, 30]
打印(a[1])                // 20
a[1] = 99
打印(a[5])                // panic: 数组下标越界: index=5, length=3

英文

var a = [10, 20, 30]
print(a[1])               // 20
a[1] = 99
print(a[5])               // panic: 数组下标越界: index=5, length=3

方法

每个方法都有拼音名和英文名，没有中文名。

拼音	英文	说明
changdu()	length()	元素个数
zhuijia(v)	push(v)	尾部追加，仅动态数组
tanchu()	pop()	弹出并返回尾元素，空数组 panic，仅动态数组
rongliang()	capacity()	当前容量
yuliu(n)	reserve(n)	预留容量至少到 n，仅动态数组

拼音

bl a leixing [z64] = [1, 2, 3]
a.zhuijia(4)
dayin(a.changdu())        // 4
bl x = a.tanchu()         // x = 4

中文

变量 a 类型 [i64] = [1, 2, 3]
a.push(4)
打印(a.length())          // 4
变量 x = a.pop()          // x = 4

英文

var a type [i64] = [1, 2, 3]
a.push(4)
print(a.length())         // 4
var x = a.pop()           // x = 4

zhuijia、tanchu、yuliu 会修改数组本身，所以和结构体方法一样：调用者必须是变量、字段或数组元素，只读数组不能调用。

预留容量

事先知道要放多少元素时，先 yuliu 一次分配到位，避免反复扩容：

拼音

bl out leixing [z64] = []
out.yuliu(1000)
jishu (bl i = 0; i < 1000; i = i +[z64] 1) {
    out.zhuijia(i)
}

中文

变量 out 类型 [i64] = []
out.reserve(1000)
计数 (变量 i = 0; i < 1000; i = i +[i64] 1) {
    out.push(i)
}

英文

var out type [i64] = []
out.reserve(1000)
for (var i = 0; i < 1000; i = i +[i64] 1) {
    out.push(i)
}

yuliu(n) 的 n 是总容量，不是"再多容纳 n 个"。

遍历

拼音

bl a leixing [z64] = [10, 20, 30]

jishu (v shuyu a) {
    dayin(v)
}
jishu (i, v shuyu a) {    // i 是下标
    dayin(i, v)
}

中文

变量 a 类型 [i64] = [10, 20, 30]

计数 (v 属于 a) {
    打印(v)
}
计数 (i, v 属于 a) {      // i 是下标
    打印(i, v)
}

英文

var a type [i64] = [10, 20, 30]

for (v in a) {
    print(v)
}
for (i, v in a) {         // i 是下标
    print(i, v)
}

遍历对象必须是变量，临时值要先存进变量；遍历得到的元素是拷贝，修改它不影响数组。

切片

a[start..end] 取下标 [start, end) 区间，复制出一个新的动态数组：

拼音

bl a leixing [z64] = [10, 20, 30, 40]

bl b = a[1..3]            // [20, 30]
bl c = a[..2]             // [10, 20]
bl d = a[2..]             // [30, 40]
bl e = a[..]              // 整体复制一份

中文

变量 a 类型 [i64] = [10, 20, 30, 40]

变量 b = a[1..3]          // [20, 30]
变量 c = a[..2]           // [10, 20]
变量 d = a[2..]           // [30, 40]
变量 e = a[..]            // 整体复制一份

英文

var a type [i64] = [10, 20, 30, 40]

var b = a[1..3]           // [20, 30]
var c = a[..2]            // [10, 20]
var d = a[2..]            // [30, 40]
var e = a[..]             // 整体复制一份

切片是独立副本，修改它不影响原数组。越界会 panic，不支持负数下标。

打印

dayin(a) 直接打印整个数组，输出形如 [1, 2, 3]。