声明和赋值

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

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

    类型推断

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

    显示指定类型

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

    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 //变量声明和赋值后,没有使用,非生产编译,只会警告,--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 b := 2
    17.     a, b = b, a // 交换
    18. }
    20. fn f3() {
    22.     mut b := 22
    23.     mut c := 33
    24.     mut d := 44
    25.     a, b, c, d = b, a++, d + 1, -c // 多变量赋值
    26.     println(a) // 22
    27.     println(b) // 11
    28.     println(c) // 45
    29.     println(d) // -33
    30. }
    32. fn f4() {
    33.     mut a, mut b, mut c := 1, 2, 3 //多变量+可变赋值
    34.     println(a)
    35.     println(b)
    36.     println(c)
    37. }

    匹配赋值

    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.     mut x:= 1 //普通的局部变量
    4.     x++
    5.     return x
    8. [unsafe] //一定要在unsafe函数中
    9. fn f_static() int {
    10.     unsafe { //在unsafe代码块中定义
    11.         mut static x:= 1 //静态局部变量
    12.         x++
    13.         return x
    14.     }
    16. }
    18. fn main() {
    19.     println(f()) //2
    20.     println(f()) //2
    21.     println(f()) //2
    22.     unsafe { //调用的时候也要使用unsafe代码块
    23.         println(f_static()) //2
    24.         println(f_static()) //3
    25.         println(f_static()) //4
    26.     }
    27. }

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

    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)