Golang 變量與常量｜Go主題月

變量

go 語言的變量聲明和大多數語言相似，經過 var 關鍵字聲明變量，只是 go 語言做爲靜態類型語言，聲明變量時須要指定其類型。markdown

下面的代碼表示聲明一個『name』變量，類型爲『string』，並給其賦值『"Shenfq"』。函數

var name string = "Shenfq"
複製代碼

若是咱們不進行賦值，這變量會得到一個默認值，下面列舉一些 go 語言中的基礎類型及其默認值。ui

類型	默認值
int（int3二、int64……）	0
uint（uint3二、uint64……）	0
float3二、float64	0.0
bool	false
string	""

多變量聲明

上面介紹 go 語言經過 var 關鍵字進行單個變量聲明，咱們還能夠經過 var 關鍵字進行多個變量的聲明：spa

// 聲明兩個變量爲同一類型
var firstName, lastName string
// 給兩個變量同時賦值
firstName, lastName = "frank", "shen"
複製代碼

// 聲明兩個變量爲不一樣類型
var (
  age int
	name string
)
// 給兩個變量同時賦值
age, name = 25, "Shenfq"
複製代碼

類型推導

若是咱們在變量聲明階段，對變量進行了賦值操做，這時候咱們是能夠直接省略變量類型的，由於 go 在編譯過程當中會依據所賦予的初始值推導出其類型。3d

var age = 25

fmt.Printf("age 類型爲：%T", age) // age 類型爲：int
複製代碼

var (
  age = 18
  name = "Shenfq"
)
fmt.Printf("age 類型爲：%T", age) // age 類型爲：int
fmt.Printf("name 類型爲：%T", name) // name 類型爲：string
複製代碼

簡短格式

前面介紹了變量聲明的時候，若是給定了初始值，go 在編譯階段能夠進行類型推導。這種狀況，go 提供了一種更簡單的聲明方式，經過 := 的方式進行變量聲明，能夠省略 var 關鍵字。code

func main() {
  age := 25
	name := "Shenfq"
}
複製代碼

// 也能夠進行多個變量同時賦值
func main() {
  age, name := 25, "Shenfq"
}
複製代碼

⚠️注意事項一

這種聲明方式只能用於函數體內，不能用於全局變量的聲明。orm

// ⚠️ 不能在全局使用這種方式聲明變量
age, name := 25, "Shenfq"

// 只能在函數體內使用該方式
func main() {
	age, name := 25, "Shenfq"
	fmt.Printf("age 類型爲：%T", age)
	fmt.Printf("name 類型爲：%T", name)
}
複製代碼

⚠️注意事項二

已經聲明過的變量，不能使用 := 的方式進行賦值。字符串

func main() {
  var age int
	age := 25
}
複製代碼

已經聲明過的變量，只能經過 = 的方式進行賦值。同步

func main() {
  var age int
	age = 25
}
複製代碼

全局變量與局部變量

簡單來講，聲明在函數體外的變量爲全局變量，聲明在函數體內的變量爲局部變量。string

局部變量若是有聲明，沒有進行使用，則不會經過編譯。

func main() {
  var age int
}
複製代碼

可是，全局變量是能夠聲明而不使用的。

var age int
func main() {
	name := "Shenfq"
	//fmt.Printf("age 類型爲：%T", age)
	fmt.Printf("name 類型爲：%T", name)
}
複製代碼

上面的代碼中，咱們聲明瞭 age 全局變量，可是並未使用，能夠正常編譯。

空白標識符

前面介紹過，go 在變量賦值的時候，能夠一次性對多個變量賦值。同時，go 的函數在 return 的時候，也能一次返回多個結果。

func double(num int) (string, int) {
	var err string
	if num < 0 {
		err = "num 不能爲負數"
		return err, -1
	}
	result := num * 2
	return err, result
}
複製代碼

上面咱們實現了一個 double 函數，該函數接受一個 int 類型的變量（num），返回兩個值，一個爲異常提示，一個爲 num * 2 的結果。若是 num < 0 ，則提示 num 不能負數。

func main() {
	err, res := double(10)
	if err != "" {
		fmt.Printf(err)
	} else {
		fmt.Printf("結果爲：%v", res)
	}
}
複製代碼

若是，咱們並不關心 err ，只想執行 double 以後，輸出其結果。

func main() {
	err, res := double(10)
	fmt.Printf("結果爲：%v", res)
}
複製代碼

運行後，咱們會收到一個編譯錯誤，err 變量並未使用。這時候，就須要用到空白標識符（_）。

func main() {
	_, res := double(10)
	fmt.Printf("結果爲：%v", res)
}
複製代碼

咱們能夠經過 _ 來接受 err 值，這個地方的值就會被拋棄掉，就能順利經過編譯。

常量

常量就是不會發生變化的變量，一旦聲明就不會改變。go 語言中，常量的聲明只須要將變量聲明時的 var 關鍵字替換爲 const 關鍵字。

// 隱式類型定義
const PI = 3.14
// 顯式類型定義
const PI2 float  = 3.14
複製代碼

多常量聲明

與變量相似，常量也支持一次性聲明多個。

func main() {
	const (
		PI = 3.14
		PI2 = 3.14
	)
	fmt.Printf("結果爲：%v\n", PI)
	fmt.Printf("結果爲：%v\n", PI2)
}
複製代碼

若是一次聲明多個常量時，某個常量若是爲進行賦值，默認會與上一個常量的值進行同步。下面代碼的運行結果，與上面的代碼一致。

func main() {
	const (
		PI = 3.14
		PI2
	)
	fmt.Printf("結果爲：%v\n", PI)
	fmt.Printf("結果爲：%v\n", PI2)
}
複製代碼

特殊常量

有個叫作 iota 的特殊常量，在常量的賦值過程當中，會進行累加。

func main() {
	const (
		A = iota
		B
		C
	)
	fmt.Println(A, B, C) // 0 1 2
}
複製代碼

在 iota 累加的過程當中，能夠對其進行打斷。

func main() {
	const (
		A = iota
		B
		C = "Shenfq"
    D
    E
	)
	fmt.Println(A, B, C, D, E)
}
複製代碼

這時候輸出的結果爲：

這是因爲咱們將常量 C 修改成了字符串 "Shenfq"，常量 D、E 會默認與上一條常量保持同步，因此會獲得上述結果。可是， iota 是支持從新恢復累加，只須要在指定位置從新賦值一次 iota 便可。

func main() {
	const (
		A = iota
		B
		C = "Shenfq"
		D = iota // 恢復累加狀態
		E
	)
	fmt.Println(A, B, C, D, E)
}

複製代碼

因爲 C 佔用了本來 2 的位置，因此 D 恢復後，也是從 3 開始的。

iota 這種累加的特性，特別像咱們在其餘語言中使用的枚舉，因此在 go 語言中，咱們能夠直接將 iota 當作枚舉來使用。

type ButtonType int
const (
  Default ButtonType = iota
  Primary
  Warning
  Error
)
複製代碼