Go 專欄 ｜ 變量和常量的聲明與賦值

上篇文章介紹了環境搭建，並完成了學習 Go 的第一個程序 Hello World。這篇文章繼續學習 Go 的基礎知識，來看看變量，常量的聲明與賦值。

本文全部代碼基於 go1.16.6 編寫。

變量

Go 編程的命名風格更習慣使用「短名稱」和「駝峯式」的名稱，並且大小寫敏感。

開頭必須是字母或者下劃線，並且首字母是大寫仍是小寫也是有特殊含義的。大寫字母開頭能夠被包外引用，小寫字母開頭只能在包內使用，這個會在之後的文章中繼續分享。

聲明

第一種使用關鍵字 var 聲明變量：

var name type = expression
複製代碼

和 C 語言正好相反，類型是跟在變量名後面的。說實話，剛開始寫 Go 代碼的時候還真有些不習慣。

類型和表達式能夠省略一個，但不能都省略。若是類型省略，則類型由初始化表達式決定；若是表達式省略，則初始化值爲對應類型的零值。

對於數字是 0，布爾值是 false，字符串是 ""，接口和引用（slice，指針，map，通道，函數）是 nil，對於數組或結構體這樣的複合類型，零值是其全部元素或成員的零值。

// 沒有初始值，會賦默認零值
var v1 int
var v2 string
var v3 bool
var v4 [10]int // 數組
var v5 []int   // 數組切片
var v6 struct {
	e int
}
var v7 *int           // 指針
var v8 map[string]int // map，key 爲 string 類型，value 爲 int 類型
var v9 func(e int) int
fmt.Println(v1, v2, v3, v4, v5, v6, v7, v8, v9)

// 輸出
// 0 false [0 0 0 0 0 0 0 0 0 0] [] {0} <nil> map[] <nil>
複製代碼

因此在 Go 中是不存在未初始化的變量的。

聲明單個變量：

// 聲明單個變量
var a = "initial"
fmt.Println(a)

// 聲明布爾值變量
var d = true
fmt.Println(d)
複製代碼

一次聲明多個變量：

// 聲明多個變量
var b, c int = 1, 2
fmt.Println(b, c)
複製代碼

建議以組方式一次聲明多個變量：

// 以組的方式聲明多個變量
var (
	b1, c1 int
	b2, c2 = 3, 4
)
fmt.Println(b1, c1)
fmt.Println(b2, c2)
複製代碼

第二種方式是短變量聲明：

name := expression
複製代碼

使用 := 來聲明，Go 編譯器會自動推斷變量類型。注意 := 和 = 的區別，前者是聲明並賦值，後者是賦值。

這種初始化方式很是方便，在局部變量的聲明和初始化時常常使用。

舉個例子：

// 短變量聲明方式
f := "short"
fmt.Println(f)
複製代碼

多個變量：

// 聲明賦值多個變量
g, h := 5, "alwaysbeta"
fmt.Println(g, h)
複製代碼

有一點須要注意，多個變量聲明時，最少有一個新變量，不然會報錯。

var i int
// i := 100 // 報錯 no new variables on left side of :=
i, j := 100, 101 // 有新值 j，不報錯
fmt.Println(i, j)
複製代碼

第三種使用內置 new 函數：

p := new(T)
複製代碼

初始化爲類型 T 的零值，並返回其地址。

先說一下如何獲取變量的地址，其實很簡單，使用取地址符 & 便可。

聲明一個整型的變量，而後對其取地址：

// 指針
k := 6
l := &k         // l 爲整型指針，指向 k
fmt.Println(*l) // 輸出 6
*l = 7
fmt.Println(k) // 輸出 7
複製代碼

使用 new 函數聲明變量：

// 使用內置函數 new 聲明
var p = new(int)
fmt.Println(*p) // 輸出整型默認值 0
*p = 8
fmt.Println(*p) // 輸出 8
複製代碼

再來看一個例子，下面兩個函數是等價的，惟一的區別就是使用 new 少聲明瞭一箇中間變量。

func newInt() *int {
	return new(int)
}

func newInt1() *int {
	var p int
	return &p
}
複製代碼

賦值

使用 = 來賦值：

舉例：

// 變量賦值
var m, n int
m = 9
n = 10
fmt.Println(m, n)
複製代碼

多重賦值：

// 變量賦值
var m, n int
m = 9
n = 10
m, n = n, m
fmt.Println(m, n)
複製代碼

這個特性真是很爽，想一想在 C 語言中是不能這麼作的，要實現相同的效果，必需要藉助一箇中間變量才行。

若是有不須要的變量，使用空標識符 _ 來忽略，在 Go 語言中，若是聲明瞭變量而不使用，程序是會報錯的。

// 空標識符
r := [5]int{1, 2, 3, 4, 5}
for _, v := range r {
	// fmt.Println(i, v)
	// fmt.Println(v) // 定義 i 但不用會報錯 i declared but not used
	fmt.Println(v) // 忽略索引
}
複製代碼

做用域

變量分爲全局變量和局部變量，局部變量會覆蓋全局變量：

// 全局變量
var gg = "global"

func main() {
    // 做用域
	fmt.Println(gg) // 輸出 global
	gg = "local"
	fmt.Println(gg) // 輸出 local
}
複製代碼

使用流程控制語句時，須要特殊注意變量的做用域：

// 條件分支下的做用域
if f, err := os.Open("./00_hello.go"); err != nil {
	fmt.Println(err)
}
f.Close()	// 報錯 f.Close undefined (type string has no field or method Close)
複製代碼

正確的寫法：

// 正確寫法
file, err := os.Open("00_hello.go")
if err != nil {
	fmt.Println(err)
}
file.Close()
複製代碼

常量

常量表示在程序運行過程當中恆定不變的值。

聲明

使用關鍵字 const 來聲明，語法和變量相似。

通常在給常量起名的時候，會起一個有明確含義的名字。

const Pi float64 = 3.14159265358979323846
複製代碼

聲明單個常量：

// 無類型整型常量
const n = 500000000

// 用編譯階段便可計算出值的表達式來賦值
const d = 3e20 / n
fmt.Println(d)
// 無類型浮點常量
const zero = 0.0
複製代碼

聲明多個常量

// 無類型整型和字符串常量
const a, b, c = 3, 4, "foo"
fmt.Println(a, b, c)

// 多個常量
const (
	size int64 = 1024
	eof        = -1 // 無類型整型常量
)
fmt.Println(size, eof)
複製代碼

iota

常量聲明還有可使用常量生成器 iota，它不會顯示寫出常量的值，而是從 0 開始，逐項加 1。

// 從 0 值開始，逐項加 1
const (
	a0 = iota // 0
	a1 = iota // 1
	a2 = iota // 2
)
fmt.Println(a0, a1, a2)

// 簡寫，表達式相同，能夠省略後面的
const (
	b0 = iota // 0
	b1        // 1
	b2        // 2
)
fmt.Println(b0, b1, b2)

const (
	b         = iota      // 0
	c float32 = iota * 10 // 10
	d         = iota      // 2
)
fmt.Println(b, c, d)
複製代碼

iota 在每一個 const 開頭被重置爲 0。

// iota 在每一個 const 開頭被重置爲 0
const x = iota // 0
fmt.Println(x)

// 同上
const y = iota // 0
fmt.Println(y)
複製代碼

還能夠用來做爲枚舉類型，好比一週 7 天，天天用一個數字表示，那麼能夠這麼聲明：

// 枚舉
const (
	Sunday    = iota // 0
	Monday           // 1
	Tuesday          // 2
	Wednesday        // 3
	Thursday         // 4
	Friday           // 5
	Saturday         // 6
)
fmt.Println(Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday)
複製代碼

總結

本文主要介紹了變量和常量的聲明和賦值，變量聲明主要有三種方式：

1. 使用關鍵字 var 來聲明；
2. 使用 := 的短變量聲明方式；
3. 使用內置函數 new。

其中短變量方式在聲明局部變量時常常使用，並且還要注意不要和賦值 = 弄混。

常量聲明和變量相似，只須要把 var 換成 const 便可。

常量還有一種特殊的聲明方式，使用 iota。它不會顯示寫出常量的值，而是從 0 開始，逐項加 1。

變量的做用域分爲全局變量和局部變量，局部變量能夠覆蓋全局變量，使用時須要注意。

---

文章中的腦圖和源碼都上傳到了 GitHub，有須要的同窗可自行下載。

地址： github.com/yongxinz/go…

關注公衆號 AlwaysBeta，回覆「goebook」領取 Go 編程經典書籍。

Go 專欄文章列表：

1. 開發環境搭建以及開發工具 VS Code 配置