从数组的源代码实现看，也是一个struct

    vlib/builtin/array.v

    2. println(arr.data) //返回数组地址:0x7ff0d2c01270
    3. println(arr.len)  //返回5
    4. println(arr.cap)  //返回5
    5. println(arr.element_size) //返回4

    数组定义

    根据首个元素的类型来决定数组的类型

    [1, 2, 3]的数组类型是[]int

    [‘a’, ‘b’]的数组类型是[]string

    数组元素的类型必须是一样的,不允许异构数组,[1, ‘a’] 编译不会通过

    固定长度数组

    对于固定长度数组来说,长度也是类型的一部分,[5]int和[6]int是两个不同的类型

    固定长度数组无法使用<<追加元素

    1. fn main() {
    2.     mut arr := [8]int{} //声明长度固定的数组,所有数组元素默认都是0值初始化
    3.     println(arr[1]) //返回0
    4.     arr = [0, 1, 2, 3, 4, 5, 6, 7]! //初始化,注意数组后面有个!,否则会报错
    5.     // arr = [0, 1, 2, 3, 4, 5, 6]! //报错,因为长度不匹配
    6.     println(arr[1]) //赋值成功后,返回1
    7.     println(arr[2]) //赋值成功后,返回2
    8.     arr[2] = 222
    9.     println(arr)
    10.     println(arr.len) //固定长度数组,返回长度8
    11.     // arr << 9 //报错,固定长度数组无法使用<<动态追加元素
    12.     x := 2.32
    13.     mut v := [8]f64{}
    14.     println(v[1]) //返回0.000000
    15.     v = [1.0, x, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0]!
    16.     println(v[1]) //赋值成功后,返回2.320000
    17. }

    数组初始化

    1. module main
    3. fn main() {
    4.     //定义初始len为5,cap为20,初始值为10的数组
    5.     mut arr := []int{len: 5, cap: 20, init: 10}
    6.     println(arr) //输出[10, 10, 10, 10, 10]
    7.     println('$arr.len,$arr.cap') //输出5,20
    8.     arr << 3
    9.     println(arr) //输出[10, 10, 10, 10, 10, 3]
    10. }

    定义一个指定长度,指定默认值的数组:

    1. arr := [0].repeat(50) //元素初始值为0,长度为50,容量为50
    2. println(arr.len) //返回50
    3. println(arr.cap) //返回50
    1. arr := ['a','b'].repeat(3) //元素初始值为a,b,重复3次,长度为6,容量为6
    2. println(arr.len) //返回6
    3. println(arr.cap) //返回6
    4. println(arr) //返回['a','b','a','b','a','b']

    数组的追加运算符: <<

    可以把一个元素追加到数组中,也可以把一个数组追加到数组中

    实际使用中需要注意的是 << 运算符是采用值复制的方式追加到数组中

    1. mut nums := [1, 2, 3, 4]
    2. println(nums) // "[1, 2, 3, 4]"
    3. nums << [5, 6, 7] //把一个数组追加到数组中
    4. println(nums) // "[1, 2, 3, 4, 5, 6, 7]"

    指针类型数组:

    1. mut arr := []&int{}
    2. b := 2
    3. c := 3
    4. arr << &a
    5. arr << &b
    6. arr << &c
    7. for i in arr {
    8.     println(i) //输出数组的3个地址元素
    9. }

    判断元素是否在数组里

    2. names << 'Peter'
    3. names << 'Sam'
    4. println('Alex' in names) //false

    !in操作符

    in的反操作符,判断元素是否不在数组里

    1. println('aa' !in names) //true

    遍历数组

    1. numbers := [1, 2, 3, 4, 5]
    2. for num in numbers {
    3.     println('num:$num')
    4. }
    5. for i, num in numbers {
    6.     println('i:$i,num:$num')
    7. }
    8. //或者这种区间的写法也可以,不过不推荐使用,用上面的就够了
    9. for i in 0 .. numbers.len {
    10.     println('num:${numbers[i]}')
    11. }

    数组切片/区间

    访问数组的错误处理

    当访问数组成员的索引越界或者别的错误,可以使用or代码块来进行错误处理

    1. module main
    3. fn main() {
    4.     arr := [1, 2, 3]
    5.     large_index := 999
    6.     // var1:=arr[large_index] //直接报数组越界错误
    7.     //增加or代码块后,可以进行错误的处理,而不是直接报错
    8.     x := arr[large_index] or { panic('out of bounds') }
    9.     println(x)
    10.     myfn()
    11. }
    13. fn myfn() ? {
    14.     arr:=[1,2,3]
    15.     large_index:=999
    16.     x := arr[large_index] ? //也可以本层级不处理,向上抛转错误
    17.     println(x)
    18. }
    1. fn main() {
    2.     mut a := [12.5, 6.5, -17.25]
    3.     mut res := []f64{cap:2}
    4.     for i in [1, 4] {
    5.         // 检查数组a[i]是否存在,如果存在,则赋值,if条件返回true,如果不存在,则返回false
    6.         if x := a[i] { 
    7.             res << x
    8.         } else {
    9.             res << -23.0
    10.         }
    11.     }
    12.     println(res)  //返回 [6.5, -23.0]
    13. }

    数组解构赋值

    目前数组的解构赋值只能用在传递给不确定参数函数,不像js中那样灵活

    1. module main
    3.     a := ['a', 'b', 'c']
    4.     println(variadic_fn_a(...a)) //数组解构赋值后,传递给不确定参数数组
    5. }
    7. fn variadic_fn_a(a ...string) string {
    8.     return variadic_fn_b(...a) //数组解构赋值后,传递给不确定参数数组
    9. }
    11. fn variadic_fn_b(a ...string) string {
    12.     a0 := a[0]
    13.     a1 := a[1]
    14.     a2 := a[2]
    15.     return '$a0$a1$a2'
    16. }

    数组排序

    V语言提供了一个内置的数组排序语法,不仅可以对基本类型数组进行排序,也可以对结构体类型数组进行排序.

    1. module main
    3. struct User {
    4.     age  int
    5.     name string
    6. }
    8. fn main() {
    9.     //基本类型数组
    10.     mut numbers := [1, 3, 2]
    11.     numbers.sort() // 1, 2, 3,默认升序,即 a < b,小于号表示从小到大
    12.     println(numbers)
    13.     numbers.sort(a > b) // 3, 2, 1,降序排序,即 a > b,大于号表示从大到小
    14.     // numbers.sort(aa > bb) // 只能用a和b这两个变量名,其他变量名会编译不通过
    15.     println(numbers)
    16.     //结构体类型数组
    17.     mut users := [User{21, 'Bob'}, User{20, 'Zarkon'},
    18.         User{25, 'Alice'},
    19.     ]
    20.     users.sort(a.age < b.age) //用结构体的某个字段进行排序
    21.     println(users)
    22.     users.sort(a.name > b.name) //字符串类型也可以排序
    23.     println(users)
    24. }

    数组内置函数

    filter( ), map( ), any( ), all( )这四个内置函数都是在编译器内部实现的,比较特殊

    具体用法参考

    维度的数量不仅仅于1,2维,不限

    1. module main
    3. fn main() {
    4.     // 2维数组
    5.     a := [1, 2, 3]
    6.     b := [4, 5, 6]
    7.     c := [7, 8, 9]
    8.     d := [[a, b, c], [b, c, a], [c, a, b]]
    9.     println(d)
    10.     println(d[0].len) //返回3
    11.     println(d[0][0].len) //返回3
    12.     // 2维数组
    13.     mut aa := [][]int{len: 2, init: []int{len: 3}}
    14.     aa[0][1] = 2
    15.     println(aa) // [[0, 2, 0], [0, 0, 0]]
    16.     // 3维数组
    17.     mut aaa := [][][]int{len: 2, init: [][]int{len: 3, init: []int{len: 2}}}
    18.     aaa[0][1][1] = 2

    数组相关的源代码可以参考v源代码中的：vlib/builtin/array.v

    更多数组相关的函数,参考标准库章节