語法糖(英語：Syntactic sugar)是由英國計(jì)算機(jī)科學(xué)家彼得·蘭丁發(fā)明的一個(gè)術(shù)語，指計(jì)算機(jī)語言中添加的某種語法，這種語法對語言的功能沒有影響，但是更方便程序員使用。

語法糖可以讓程序更加簡潔，有更高的可讀性。具體在 Go 語言中，有哪些常見語法糖呢?本文來盤點(diǎn)一下。

1. 短變量聲明

在 Go 函數(shù)中，我們可使用name:= expression的語法形式來聲明和初始化局部變量。該語法糖的功能是聲明(類型推斷)和賦值。

例如x:=1與下面幾種形式是等價(jià)的

// 形式一
var x int
x = 1
// 形式二
var x int = 1
// 形式三
var x = 1

需要注意幾個(gè)規(guī)則

• 不能在函數(shù)外使用 := ，因?yàn)樵谌魏魏瘮?shù)外，語句都應(yīng)該以關(guān)鍵字開頭，例如 type、var這樣的關(guān)鍵字。

// 不合法
x := 42
// 合法
var y = 42

func main() {
 // 合法
 z:= 42
}

:= 代表引入一個(gè)新的變量，所以不能在同一作用域使用相同的 := 語句兩次。

x := 1
x := 1 // 重復(fù)定義，錯(cuò)誤

在多變量聲明中，如果其中一個(gè)變量是新的，可以使用 := 兩次

x, y := 1, 2
y, z := 3, 4 // z 是新的變量
x, z := 5, 6 // 錯(cuò)誤，x、z 均已定義過

可以使用 := 在新的作用域中聲明變量，即使該變量之前已經(jīng)用相同的名稱聲明過。

var x int = 1

func some() {
  x := 2
  ...
}

可以在短語句塊中聲明相同的名稱，例如：if、for、switch 中，但它們有各自作用域。

func main() {
 x := 1
 if true {
  x := 2
  fmt.Printf("x = %d\n", x) // x = 2
 }
 fmt.Printf("x = %d\n", x) // x = 1
}

所以，如果你想輕松聲明一個(gè)變量，你可以使用:=;但如果你只想覆蓋一個(gè)現(xiàn)有的變量，你應(yīng)該使用=。

2. new 函數(shù)

Go 內(nèi)置的new函數(shù)是另一種創(chuàng)建變量的方式，表達(dá)式new(T)創(chuàng)建一個(gè)未命名的 T 類型變量，初始化為 T 類型的零值，并返回其地址(類型為 *T)。

例如，下面兩個(gè)newInt函數(shù)是等價(jià)的

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

func newInt() *int {
 var x int
 return &x
}

很明顯，new函數(shù)的設(shè)計(jì)同樣是為了方便程序員的使用。

3. ...與切片

在 Go 函數(shù)定義中，我們可以使用...表示可變參數(shù)，用于表示可以接受任意個(gè)數(shù)但相同類型的參數(shù)。

最經(jīng)典的例子就是fmt包下的Println函數(shù)

func Println(a ...interface{}) (n int, err error) {}

…T語法糖本質(zhì)上代表的是一個(gè)切片，其元素類型為T。因此，...interface{}類型等價(jià)于[]interface{}，這也是為什么Println函數(shù)可以接受任意數(shù)量，任意類型的參數(shù)原因。

Println函數(shù)我們可以稱之為可變參函數(shù)?？勺儏⒑瘮?shù)具有以下特征

• 可變參必須定義在函數(shù)參數(shù)列表最后一個(gè)，也只能有一個(gè)可變參類型定義。
• 函數(shù)調(diào)用時(shí)，可變參可以不填，此時(shí)函數(shù)內(nèi)部會(huì)將其當(dāng)做 nil 切片處理。
• 可變參數(shù)必須是相同類型，如果需要不同類型就定義為 interface{}。

...還可用于切片初始化中。

思考一下，如果讓你初始化一個(gè) int 切片，除了第 50 位值為 1，第 99 位值為2，其余位均為 0，你會(huì)如何定義?

如果運(yùn)用...語法糖，我們可以這樣做

x := [...]int{49: 1, 98: 2, 99: 0}

4. 接收者方法

在 Go 中，對于自定義類型 T，為它定義方法時(shí)，其接收者可以是類型 T 本身，也可能是 T 類型的指針 *T。

type Instance struct{}

func (ins *Instance) Foo() string {
 return ""
}

在上例中，我們定義了 Instance 的 Foo 方法時(shí)，其接收者是一個(gè)指針類型(*Instance)。

func main() {
 var _ = Instance{}.Foo() // 編譯錯(cuò)誤：cannot call pointer method on Instance{}
}

因此，如果我們用 Instance 類型本身 Instance{} 值去調(diào)用 Foo 方法，將會(huì)得到以上錯(cuò)誤。

type Instance struct{}

func (ins Instance) Foo() string {
 return ""
}

func main() {
 var _ = Instance{}.Foo() // 編譯通過
}

此時(shí)，如果我們將 Foo 方法的接收者改為 Instance 類型，就沒有問題。

這說明，定義類型 T 的函數(shù)方法時(shí)，其接收者類型決定了之后什么樣的類型對象能去調(diào)用該函數(shù)方法。但，實(shí)際上真的是這樣嗎?

type Instance struct{}

func (ins *Instance) String() string {
 return ""
}

func main() {
 var ins Instance
 _ = ins.String()
}

實(shí)際上，即使是我們在實(shí)現(xiàn) Foo 方法時(shí)的接收者是指針類型，上面 ins 調(diào)用的使用依然沒有問題。

Ins 值屬于 Instance 類型，而非 *Instance，卻能調(diào)用 Foo 方法，這是為什么呢?這其實(shí)就是 Go 編譯器提供的語法糖!

當(dāng)一個(gè)變量可變時(shí)，我們對類型 T 的變量直接調(diào)用 *T 方法是合法的，因?yàn)?Go 編譯器隱式地獲取了它的地址。變量可變意味著變量可尋址，因此，上文提到的 Instance{}.Foo() 會(huì)得到編譯錯(cuò)誤，就在于 Instance{} 值不能尋址。

5. for range

循環(huán)是所有編程語言都會(huì)涉及的控制單元，最經(jīng)典的就是三段式循環(huán)。

for i := 0; i < len(arr); i++ {}

每次都寫三段式是不是比較麻煩?因此，在 Go 中，我們可以使用 for range 來快速遍歷可迭代對象，例如數(shù)組、切片、map、channel、字符串等。

對于切片、數(shù)組、字符串，其 for range 遍歷方式有三種

a := []int{1, 2, 3}

// 遍歷一：不關(guān)心索引和數(shù)據(jù)的情況
for range a {
}

// 遍歷二：只關(guān)心索引的情況
for index := range a {
 fmt.Println(index)
}

// 遍歷三：關(guān)心索引和數(shù)據(jù)的情況
for index, value := range a {
 fmt.Println(index, value)
}

map 也有三種 for range 遍歷方式

m := map[int]string{1: "Golang", 2: "Python", 3: "Java"}
// 遍歷一：不關(guān)心 key 和 value 的情況
for range m {
}

// 遍歷二：只關(guān)心 key 的情況
for key := range m {
 fmt.Println(key)
}

// 遍歷二：關(guān)心 key 和 value 的情況
for key, value := range m {
 fmt.Println(key, value)
}

對于 channel，有兩種 for range 遍歷方式

ch := make(chan int, 10)

// 遍歷一：不關(guān)心 channel 數(shù)據(jù)
for range ch {
}

// 遍歷二：關(guān)心 channel 數(shù)據(jù)
for data := range ch {
 fmt.Println(data)
}

Go 編譯器會(huì)將不同的 for range 遍歷方式轉(zhuǎn)換成不同的控制邏輯，簡化使用邏輯，使得程序員能夠更方便地對可迭代對象進(jìn)行遍歷處理。

總結(jié)

語法糖能讓程序員使用更簡練的言語表達(dá)較復(fù)雜的含義，它的本質(zhì)是編譯器做了額外的處理邏輯。

本文列出了 Go 的一些語法糖規(guī)則，童鞋們之前都了解嗎?如有遺漏，歡迎補(bǔ)充~