除了内置的基本类型外,数组和字典也是内置类型。
数组实现
从数组的源代码实现看，也是一个struct。
vlib/builtin/array.v
复制 struct array {
pub : //公共只读
data voidptr //数组的起始指针
len int //数组的长度
cap int //数组的容量
element_size int //数组元素的字节大小
}
复制 arr := [ 1 , 2 , 3 , 4 , 5 ] //字面量定义数组
println (arr.data) //返回数组地址:0x7ff0d2c01270
println (arr.len) //返回5
println (arr.cap) //返回5
println (arr.element_size) //返回4 数组定义
根据首个元素的类型来决定数组的类型，
[1, 2, 3]的数组类型是[ ]int，
['a', 'b']的数组类型是[ ]string，
数组元素的类型必须是一样的，不允许异构数组，[1, 'a'] 编译不会通过。
固定长度数组
对于固定长度数组来说，长度也是类型的一部分，[5]int和[6]int是两个不同的类型。
固定长度数组无法使用<<追加元素。
复制 fn main () {
mut arr := [ 8 ] int {} //声明长度固定的数组,所有数组元素默认都是0值初始化
println (arr[ 1 ]) //返回0
arr = [ 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 ] ! //初始化,注意数组后面有个!,否则会报错
for a in arr { //使用for in遍历固定长度数组
println (a)
}
// arr = [0, 1, 2, 3, 4, 5, 6]! //报错,因为长度不匹配
println (arr[ 1 ]) //赋值成功后,返回1
println (arr[ 2 ]) //赋值成功后,返回2
arr[ 2 ] = 222
println (arr)
println (arr.len) //固定长度数组,返回长度8
// arr << 9 //报错,固定长度数组无法使用<<动态追加元素
x := 2.32
mut v := [ 8 ] f64 {}
println (v[ 1 ]) //返回0.000000
v = [ 1.0 , x , 3.0 , 4.0 , 5.0 , 6.0 , 7.0 , 8.0 ] !
println (v[ 1 ]) //赋值成功后,返回2.320000
} 数组初始化
可以在定义数组时明确指定len，cap，init进行初始化。
也可以使用数组的索引值it，it是iterator迭代器的缩写，来动态地初始化数组元素值。
复制 module main
fn main () {
//定义初始len为5,cap为20,初始值为10的数组
mut arr := [] int {len: 5 , cap: 20 , init: 10 }
println (arr) //输出[10, 10, 10, 10, 10]
println ( '$arr.len,$arr.cap' ) //输出5,20
arr << 3
println (arr) //输出[10, 10, 10, 10, 10, 3]
//使用it来动态地初始化数组的元素值
mut square := [] int {len: 6 , init: it * it }
println (square) //输出[0, 1, 4, 9, 16, 25]
} 定义一个指定长度，指定默认值的数组：
复制 arr := [ 0 ]. repeat ( 50 ) //元素初始值为0,长度为50,容量为50
println (arr.len) //返回50
println (arr.cap) //返回50
复制 arr := [ 'a' , 'b' ]. repeat ( 3 ) //元素初始值为a,b,重复3次,长度为6,容量为6
println (arr.len) //返回6
println (arr.cap) //返回6
println (arr) //返回['a','b','a','b','a','b'] 数组的追加运算符：<<可以把一个元素追加到数组中，也可以把一个数组追加到数组中。
实际使用中需要注意的是 << 运算符是采用值复制的方式追加到数组中。
复制 mut nums := [ 1 , 2 , 3 ]
println (nums) // "[1, 2, 3]"
nums << 4 //把一个元素追加到数组中
println (nums) // "[1, 2, 3, 4]"
复制 mut nums := [ 1 , 2 , 3 , 4 ]
println (nums) // "[1, 2, 3, 4]"
nums << [ 5 , 6 , 7 ] //把一个数组追加到数组中
println (nums) // "[1, 2, 3, 4, 5, 6, 7]" 指针类型数组：
复制 mut arr := [] &int {}
a := 1
b := 2
c := 3
arr << & a
arr << & b
arr << & c
for i in arr {
println (i) //输出数组的3个地址元素
} in操作符
判断元素是否在数组里：
复制 mut names := [ 'John' ]
names << 'Peter'
names << 'Sam'
println ( 'Alex' in names) //false !in操作符
in的反操作符,判断元素是否不在数组里：
复制 println ( 'aa' !in names) //true 遍历数组：
复制 numbers := [ 1 , 2 , 3 , 4 , 5 ]
for num in numbers {
println ( 'num:$num' )
}
for i , num in numbers {
println ( 'i:$i,num:$num' )
}
//或者这种区间的写法也可以,不过不推荐使用,用上面的就够了
for i in 0 .. numbers.len {
println ( 'num:${numbers[i]}' )
}
数组切片/区间
左闭右开原则：
复制 n := [ 1 , 2 , 3 , 4 , 5 ]
println (n)
println (n[.. 2 ]) //返回[1, 2]
println (n[ 2 ..]) //返回[3, 4, 5]
println (n[ 2 .. 4 ]) //返回[3, 4]
//区间支持负数的索引值，不过要在数组名后特别加一个#,否则会报错
println (n#[ - 1 ..]) //返回[5]
println (n#[ - 3 .. - 1 ]) //返回[3,4] 函数调用后连写数组区间：
复制 module main
fn main () {
num_range := fn_return_array ()[ 2 ..] //函数调用后直接连写数组区间，小小的语法糖
println (num_range) //输出[3,4,5]
}
fn fn_return_array () [] int {
return [ 1 , 2 , 3 , 4 , 5 ]
} 访问数组的错误处理
当访问数组成员的索引越界或者别的错误，可以使用or代码块来进行错误处理。
复制 module main
fn main () {
arr := [ 1 , 2 , 3 ]
large_index := 999
// var1:=arr[large_index] //直接报数组越界错误
y := arr[large_index] or { 100 } //如果数组元素不存在,执行or代码块,可以返回默认值
println (y)
//增加or代码块后,进行错误的处理
x := arr[large_index] or { panic ( 'out of bounds' ) }
println (x)
myfn () or { panic ( 'myfn error' ) } //处理myfn向上抛转的错误
}
fn myfn () ! {
arr := [ 1 , 2 , 3 ]
large_index := 999
x := arr[large_index] ! //也可以本层级不处理,向上抛转错误
println (x)
}
if语句判断数组成员是否存在
复制 fn main () {
mut a := [ 12.5 , 6.5 , - 17.25 ]
mut res := [] f64 {cap: 2 }
for i in [ 1 , 4 ] {
// 检查数组a[i]是否存在,如果存在,则赋值,if条件返回true,如果不存在,则返回false
if x := a[i] {
res << x
} else {
res << - 23.0
}
}
println (res) //返回 [6.5, -23.0]
} 数组解构赋值
目前数组的解构赋值只能用在传递给不确定参数函数，不像js中那样灵活。
复制 module main
fn main () {
a := [ 'a' , 'b' , 'c' ]
println ( variadic_fn_a (...a)) //数组解构赋值后,传递给不确定参数数组
}
fn variadic_fn_a (a ...string) string {
return variadic_fn_b (...a) //数组解构赋值后,传递给不确定参数数组
}
fn variadic_fn_b (a ...string) string {
a0 := a[ 0 ]
a1 := a[ 1 ]
a2 := a[ 2 ]
return '$a0$a1$a2'
} 数组排序
V语言提供了一个内置的数组排序语法，不仅可以对基本类型数组进行排序，也可以对结构体类型数组进行排序。
复制 module main
struct User {
age int
name string
}
fn main () {
//基本类型数组
mut numbers := [ 1 , 3 , 2 ]
numbers. sort () // 1, 2, 3,默认升序,即 a < b,小于号表示从小到大
println (numbers)
numbers. sort (a > b) // 3, 2, 1,降序排序,即 a > b,大于号表示从大到小
// numbers.sort(aa > bb) // 只能用a和b这两个变量名,其他变量名会编译不通过
println (numbers)
//结构体类型数组
mut users := [User{ 21 , 'Bob' } , User{ 20 , 'Zarkon' } ,
User{ 25 , 'Alice' } ,
]
users. sort (a.age < b.age) //用结构体的某个字段进行排序
println (users)
users. sort (a.name > b.name) //字符串类型也可以排序
println (users)
}
数组内置函数
filter( )，map( )，any( )，all( )这四个内置函数都是在编译器内部实现的，比较特殊，
具体用法参考标准库章节 。
多维数组
维度的数量不仅仅于1，2维，不限：
复制 module main
fn main () {
// 2维数组
a := [ 1 , 2 , 3 ]
b := [ 4 , 5 , 6 ]
c := [ 7 , 8 , 9 ]
d := [[a , b , c] , [b , c , a] , [c , a , b]]
println (d)
println (d[ 0 ].len) //返回3
println (d[ 0 ][ 0 ].len) //返回3
// 2维数组
mut aa := [][] int {len: 2 , init: [] int {len: 3 }}
aa[ 0 ][ 1 ] = 2
println (aa) // [[0, 2, 0], [0, 0, 0]]
// 3维数组
mut aaa := [][][] int {len: 2 , init: [][] int {len: 3 , init: [] int {len: 2 }}}
aaa[ 0 ][ 1 ][ 1 ] = 2
println (aaa) // [[[0, 0], [0, 2], [0, 0]], [[0, 0], [0, 0], [0, 0]]]
}
数组相关的源代码可以参考：vlib/builtin/array.v。
更多数组相关函数，参考标准库 和arrays模块 。
