【Golang 基礎】Go 語言的變量與常量

時間 2019-12-12

原文原文鏈接

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 關鍵字。變量名是下劃線（_) 表示忽略。git

常量定義的形式，類型範圍（示例代碼）

常量定義從形式上能夠分爲顯式和隱式；github
- 顯式：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)
}

常量類型範圍目前只支持布爾型、數字型和字符串類型。golang

特殊常量 iota

iota 只能在常量的表達式中使用，在 const 關鍵字出現時， iota將被重置爲 0；
const 中每新增一行常量聲明，將使 iota 計數一次；

iota 常見用法：函數

跳值使用法code

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)
}

表達式隱式使用法get

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)
}

單行使用法string

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)
}