Go 语言的变量与常量

变量声明，初始化与赋值 （示例代码）

• 变量的声明格式：var <变量名称> [变量类型]；
• 变量的赋值格式：<变量名称> = <值，表达式，函数等>；
• 声明和赋值同时进行：var <变量名称> [变量类型] = <值，表达式，函数等>；
• 分组声明的格式

package basic

import "fmt"

func DeclaratGroupVariable(){
    // 分组声明变量
    var (
        name string
        age int = 18
    )

    name = "hvkcoder"

    fmt.Printf("Hello！My name'is %d. I'm %d years old", name, age)
}

• 简写声明格式：<变量名称> := <值，表达式，函数等>，只能在局部变量声明时使用，并且必须赋值；
• 声明多个变量，需要以 , 隔开；

package basic

import "fmt"

func DeclaratMultiVariable(){
    // 声明多个变量
    var a , b, c int
    // 为多个变量赋值
    a, b, c = 1 ,2, 3
    fmt.Printf("a = %d , b = %d , c = %d", a, b, c)

    // 声明多个变量并赋值
    var e, f, g int = 4, 5, 6
    fmt.Printf("e = %d , f = %d , g = %d", e, f, g)

    // 简写声明
    h, i, j := 7, 8, 9
    fmt.Printf("h = %d , i = %d , j = %d", h, i, j)
}

声明全局变量时，不能使用简写声明，且必须使用 var 关键字。变量名是 下划线（_) 表示忽略。

常量定义的形式，类型范围（示例代码）

• 常量定义从形式上可以分为 显式 和 隐式；

  • 显式：const <常量名称> [type] = value；
  • 隐式：const <常量名称> = value；
• 一般情况下常量名称需大写，若该常量为私有常量，只需在常量名前加 下滑线（_)，如：const _PI = 3.14；
• 常量可以使用内置表达式，如：len()，unsafe.SizeOf() 等；

package basic

import "unsafe"


func DeclaratExpression(){
    const (
        _NAME string = "hvkcoder"
        _NAME_LENGTH int = len(_NAME)
        _NAME_SIZE  = unsafe.Sizeof(_NAME)
    )
}

• 多组常量声明时，常量默认取上一个常量的值；

package basic

import "fmt"

func DeclaratGroupConstant(){
    const (
        _NAME string = "hvkcoder"
        _FIRST_NAME
    )

    fmt.Println(_NAME)
    fmt.Println(_FIRST_NAME)
}

常量类型范围目前只支持 布尔型、数字型和字符串类型。

特殊常量 iota

• iota 只能在常量的表达式中使用，在 const 关键字出现时， iota将被重置为 0；
• const 中每新增一行常量声明，将使 iota 计数一次；

• iota 常见用法：

  • 跳值使用法

    package basic
    
    import "fmt"
    
    func JumpValueByIota(){
        const (
            a = 3.14
            b
            c = iota  // 2
            d         // 3
        )
        fmt.Println(a,b,c,d)
    }

  • 插值使用法

    package basic
        
    import "fmt"    
    
    func InsertValueByIota(){
        const (
            a = iota   // 0
            b = 3.14
            c = iota   // 2
            d          // 3
        )
        fmt.Println(a,b,c,d)
    }

  • 表达式隐式使用法

    package basic
    
    import "fmt"
    
    func ExpressionByIota(){
        const (
            B = 1 << (10 * iota)  // 1
            KB                    // 1024
            MB                    // 1048576
            GB                    // 1073741824
            TB                    // 1099511627776
            PB                    // 1125899906842624
        )
    
        fmt.Println(B,KB,MB,GB,TB,PB)
    }

  • 单行使用法

    package basic
    
    import "fmt"
    
    func SingleLineByIota(){
        const (
            a , b = iota + 1, iota + 2
            c, d = iota + 3, iota + 4
    
            // a => 0 + 1
            // b => 0 + 2
            // c => 1 + 3
            // d => 1 + 4
        )
        fmt.Println(a,b,c,d)
    }

变量的类型转换

• Go 语言中不存在隐式转换，类型转换必须是显式的；
• 类型转换只能发生在两种兼容类型之间；
• 类型转换的格式：var <变量名称> [:]= <目标类型>(<需要转换的变量>);