变量

V是静态类型语言,每一个变量都有对应类型

声明和赋值

V语言中只有唯一的一种变量声明和赋值方式 :=

并且声明和赋值是要同时的,这意味着变量总会有一个初始值

1. a:=false
2. b:='abc'
3. c:=3   //默认推断为int
4. f:=3.1 //默认推断为f64

类型推断

上述的代码并没有体现出变量的类型,是因为编译器会根据变量的值自动进行类型推断

显示指定类型

如果不希望由编译器自动类型推断,可以通过T(value)的格式明确变量类型,T是类型,value是变量值

1. x:=i64(3) //x是i64类型，而不是默认推断的int
2. y:=f32(3.0) //y是f32类型，而不是默认推断的f64

判断变量类型

通过使用typeof内置函数,可以判断变量类型

1. x:=3
2. s:='abc'
3. println(typeof(x)) //int
4. println(typeof(s)) //string

默认不可变

跟rust一样,变量默认不可变,要声明为可变,使用mut关键字

1. mut age := 20
2. println(age)
3. age = 21
4. println(age)

要注意区分:=和=的不同之处:

:=的含义是为变量声明并赋值

=的含义是为变量绑定一个新的值,也可以理解为修改变量值

变量声明后，如果没有被使用：

开发模式(v run)，编译器只是会警告，但是仍然继续编译,方便开发调试，而不用去临时注释掉

生产编译模式（-prod），编译器会报错，停止编译

以下几种情况的代码,会编译不通过:

1. fn main() {
2. age = 21 //变量还未声明
3. }

1. fn main() {
2. age := 21 //变量声明和赋值后,没有使用,非生产编译,只会警告,--prod生产编译时会不通过
3. }

1. fn main() {
2. a := 10
3. if true {
4. a := 20 //跟其他语言不一样,没有上级变量隐藏,在函数内部,同名的变量只能定义一个
5. }
6. }

多变量赋值

1. fn main() {
2. f1()
3. f2()
4. f3()
5. f4()
6. }

8. fn f1() {
9. a, b, c := 1, 3, 5 // 多变量声明并赋值
10. println(a)
11. println(b)
12. println(c)
13. }

15. fn f2() {
16. mut a := 1
17. mut b := 2
18. a, b = b, a // 交换
19. }

21. fn f3() {
22. mut a := 11
23. mut b := 22
24. mut c := 33
25. mut d := 44
26. a, b, c, d = b, a++, d + 1, -c // 多变量赋值
27. println(a) // 22
28. println(b) // 11
29. println(c) // 45
30. println(d) // -33
31. }

33. fn f4() {
34. mut a, mut b, mut c := 1, 2, 3 //多变量+可变赋值
35. println(a)
36. println(b)
37. println(c)
38. }

条件赋值

1. d, e, f := if true {
2. 1, 'awesome', [13]
3. } else {
4. 0, 'bad', [0]
5. }

匹配赋值

1. a, b, c := match false {
2. true { 1, 2, 3 }
3. false { 4, 5, 6 }
4. else { 7, 8, 9 }
5. }

强制类型转换

可以通过T( ) 对类型进行显示声明,或者强制类型转换

1. module main

3. fn main() {
4. x := int(3)
5. y := byte(x)
6. println('y is $y')
7. z := f32(x)
8. println('z is $z')
9. f := 1.2
10. i := int(f)
11. println(i) // 输出1，强制转换丧失精度
12. }

静态局部变量

跟C的静态局部变量一样,用关键字 static 声明,静态局部变量的值在函数调用结束之后不会消失，而仍然保留其原值.

一般来说,普通的V代码很少会用到静态局部变量,只有跟C集成的时候才会用到.

使用静态局部变量有以下2种方式:

• 在-translated模式中使用
• 在unsafe函数和代码块中使用

1. module main

3. fn f() int {
4. mut x:= 1 //普通的局部变量
5. x++
6. return x
7. }

9. [unsafe] //一定要在unsafe函数中
10. fn f_static() int {
11. unsafe { //在unsafe代码块中定义
12. mut static x:= 1 //静态局部变量
13. x++
14. return x
15. }

17. }

19. fn main() {
20. println(f()) //2
21. println(f()) //2
22. println(f()) //2
23. unsafe { //调用的时候也要使用unsafe代码块
24. println(f_static()) //2
25. println(f_static()) //3
26. println(f_static()) //4
27. }
28. }

默认没有模块级变量/全局变量

V语言中的变量只能在函数中定义,就是局部变量,默认没有模块级变量,没有全局变量.

默认情况下编译器是没有全局变量声明的,但是为了跟C代码集成,有时候需要定义全局变量,可以在调用编译器时,通过增加 -enable-globals选项来启用

1. v -enable-globals run main.v

1. module main

3. // 单个全局变量定义
4. __global g1 int

6. // 组定义全局变量,类似常量组的定义
7. __global (
8. g2 byte
9. g3 byte
10. )

12. fn main() {
13. g1 = 1
14. g2 = 2
15. g3 = 3
16. println(g1)
17. println(g2)
18. println(g3)
19. }