Go语法糖

博主：茶白
发布时间：2019 年 09 月 21 日
暂无评论
3120字数
分类： go

语法糖（英语：Syntactic sugar）是由英国计算机科学家彼得·兰丁发明的一个术语，指计算机语言中添加的某种语法，这种语法对语言的功能没有影响，但是更方便程序员使用。

语法糖可以让程序更加简洁，有更高的可读性。具体在 Go 语言中，有哪些常见语法糖呢？本文来盘点一下。

## 1. 短变量声明

在 Go 函数中，我们可使用`name:= expression`的语法形式来声明和初始化局部变量。该语法糖的功能是声明（类型推断）和赋值。

例如`x:=1`与下面几种形式是等价的

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

需要注意几个规则

* 不能在函数外使用 `:=` ，因为在任何函数外，语句都应该以关键字开头，例如 `type`、`var`这样的关键字。
  ```go
  // 不合法
  x := 42
  // 合法
  var y = 42

func main() {
   // 合法
   z:= 42
  }
  ```
* `:=` 代表引入一个新的变量，所以不能在同一作用域使用相同的 `:=` 语句两次。
  ```go
  x := 1
  x := 1 // 重复定义，错误
  ```
* 在多变量声明中，如果其中一个变量是新的，可以使用 `:=` 两次
  ```go
  x, y := 1, 2
  y, z := 3, 4 // z 是新的变量
  x, z := 5, 6 // 错误，x、z 均已定义过
  ```
* 可以使用 `:=` 在新的作用域中声明变量，即使该变量之前已经用相同的名称声明过。
  ```go
  var x int = 1

func some() {
    x := 2
    ...
  }
  ```
* 可以在短语句块中声明相同的名称，例如：if、for、switch 中，但它们有各自作用域。
  ```go
  func main() {
   x := 1
   if true {
    x := 2
    fmt.Printf("x = %d\n", x) // x = 2
   }
   fmt.Printf("x = %d\n", x) // x = 1
  }
  ```

所以，如果你想轻松声明一个变量，你可以使用`:=`；但如果你只想覆盖一个现有的变量，你应该使用`=`。

## 2. new 函数

Go 内置的`new`函数是另一种创建变量的方式，表达式`new(T)`创建一个未命名的 T 类型变量，初始化为 T 类型的零值，并返回其地址（类型为 *T）。

例如，下面两个`newInt`函数是等价的

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

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

很明显，`new`函数的设计同样是为了方便程序员的使用。

## 3. ...与切片

在 Go 函数定义中，我们可以使用`...`表示可变参数，用于表示可以接受任意个数但相同类型的参数。

最经典的例子就是`fmt`包下的`Println`函数

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

`…T`语法糖本质上代表的是一个切片，其元素类型为`T`。因此，`...interface{}`类型等价于`[]interface{}`，这也是为什么`Println`函数可以接受任意数量，任意类型的参数原因。

`Println`函数我们可以称之为可变参函数。可变参函数具有以下特征

* 可变参必须定义在函数参数列表最后一个，也只能有一个可变参类型定义。
* 函数调用时，可变参可以不填，此时函数内部会将其当做 nil 切片处理。
* 可变参数必须是相同类型，如果需要不同类型就定义为 interface{}。

`...`还可用于数组初始化中。

思考一下，如果让你初始化一个 int 数组，除了第 50 位值为 1，第 99 位值为2，其余位均为 0，你会如何定义？

如果运用`...`语法糖，我们可以这样做

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

## 4. 接收者方法

在 Go 中，对于自定义类型 T，为它定义方法时，其接收者可以是类型 T 本身，也可能是 T 类型的指针 *T。

```go
type Instance struct{}

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

在上例中，我们定义了 Instance 的 Foo 方法时，其接收者是一个指针类型（*Instance）。

```go
func main() {
 var _ = Instance{}.Foo() // 编译错误：cannot call pointer method on Instance{}
}
```

因此，如果我们用 Instance 类型本身 Instance{} 值去调用 Foo 方法，将会得到以上错误。

```go
type Instance struct{}

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

func main() {
 var _ = Instance{}.Foo() // 编译通过
}
```

此时，如果我们将 Foo 方法的接收者改为 Instance 类型，就没有问题。

这说明，定义类型 T 的函数方法时，其接收者类型决定了之后什么样的类型对象能去调用该函数方法。但，实际上真的是这样吗？

```go
type Instance struct{}

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

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

实际上，即使是我们在实现 Foo 方法时的接收者是指针类型，上面 ins 调用的使用依然没有问题。

Ins 值属于 Instance 类型，而非 *Instance，却能调用 Foo 方法，这是为什么呢？这其实就是 Go 编译器提供的语法糖！

**当一个变量可变时，我们对类型 T 的变量直接调用 *T 方法是合法的，因为 Go 编译器隐式地获取了它的地址。** 变量可变意味着变量可寻址，因此，上文提到的 `Instance{}.Foo()` 会得到编译错误，就在于 Instance{} 值不能寻址。

## 5. for range

循环是所有编程语言都会涉及的控制单元，最经典的就是三段式循环。

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

每次都写三段式是不是比较麻烦？因此，在 Go 中，我们可以使用 for range 来快速遍历可迭代对象，例如数组、切片、map、channel、字符串等。

对于切片、数组、字符串，其 for range 遍历方式有三种

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

// 遍历一：不关心索引和数据的情况
for range a {
}

// 遍历二：只关心索引的情况
for index := range a {
 fmt.Println(index)
}

// 遍历三：关心索引和数据的情况
for index, value := range a {
 fmt.Println(index, value)
}
```

map 也有三种  for range 遍历方式

```go
m := map[int]string{1: "Golang", 2: "Python", 3: "Java"}
// 遍历一：不关心 key 和 value 的情况
for range m {
}

// 遍历二：只关心 key 的情况
for key := range m {
 fmt.Println(key)
}

// 遍历二：关心 key 和 value 的情况
for key, value := range m {
 fmt.Println(key, value)
}
```

对于 channel，有两种 for range 遍历方式

```go
ch := make(chan int, 10)

// 遍历一：不关心 channel 数据
for range ch {
}

// 遍历二：关心 channel 数据
for data := range ch {
 fmt.Println(data)
}
```

Go 编译器会将不同的 for range 遍历方式转换成不同的控制逻辑，简化使用逻辑，使得程序员能够更方便地对可迭代对象进行遍历处理。

最后修改：2019 年 09 月 21 日

如果觉得我的文章对你有用，请随意赞赏

发表评论取消回复

评论 *

私密评论

名称 *

🎲

邮箱 *

地址 *

姓名
GPT-4 currently has a cap of 25...
曲阜
有没有兴趣来我们公司工作？可联系微信geezzi
Rorinl
谢谢ヾ(≧∇≦*)ゝ
rorinl
该评论仅登录用户及评论双方可见

Go语法糖

茶白 • 2019 年 09 月 21 日

语法糖可以让程序更加简洁，有更高的可读性。具体在 Go 语言中，有哪些常见语法糖呢？本文来盘点一下。

## 1. 短变量声明

在 Go 函数中，我们可使用`name:= expression`的语法形式来声明和初始化局部变量。该语法糖的功能是声明（类型推断）和赋值。

例如`x:=1`与下面几种形式是等价的

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

需要注意几个规则

所以，如果你想轻松声明一个变量，你可以使用`:=`；但如果你只想覆盖一个现有的变量，你应该使用`=`。

## 2. new 函数

Go 内置的`new`函数是另一种创建变量的方式，表达式`new(T)`创建一个未命名的 T 类型变量，初始化为 T 类型的零值，并返回其地址（类型为 *T）。

例如，下面两个`newInt`函数是等价的

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

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

很明显，`new`函数的设计同样是为了方便程序员的使用。

## 3. ...与切片

在 Go 函数定义中，我们可以使用`...`表示可变参数，用于表示可以接受任意个数但相同类型的参数。

最经典的例子就是`fmt`包下的`Println`函数

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

`Println`函数我们可以称之为可变参函数。可变参函数具有以下特征

`...`还可用于数组初始化中。

思考一下，如果让你初始化一个 int 数组，除了第 50 位值为 1，第 99 位值为2，其余位均为 0，你会如何定义？

如果运用`...`语法糖，我们可以这样做

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

## 4. 接收者方法

在 Go 中，对于自定义类型 T，为它定义方法时，其接收者可以是类型 T 本身，也可能是 T 类型的指针 *T。

```go
type Instance struct{}

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

在上例中，我们定义了 Instance 的 Foo 方法时，其接收者是一个指针类型（*Instance）。

```go
func main() {
 var _ = Instance{}.Foo() // 编译错误：cannot call pointer method on Instance{}
}
```

因此，如果我们用 Instance 类型本身 Instance{} 值去调用 Foo 方法，将会得到以上错误。

```go
type Instance struct{}

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

func main() {
 var _ = Instance{}.Foo() // 编译通过
}
```

此时，如果我们将 Foo 方法的接收者改为 Instance 类型，就没有问题。

这说明，定义类型 T 的函数方法时，其接收者类型决定了之后什么样的类型对象能去调用该函数方法。但，实际上真的是这样吗？

```go
type Instance struct{}

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

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

实际上，即使是我们在实现 Foo 方法时的接收者是指针类型，上面 ins 调用的使用依然没有问题。

Ins 值属于 Instance 类型，而非 *Instance，却能调用 Foo 方法，这是为什么呢？这其实就是 Go 编译器提供的语法糖！

## 5. for range

循环是所有编程语言都会涉及的控制单元，最经典的就是三段式循环。

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

每次都写三段式是不是比较麻烦？因此，在 Go 中，我们可以使用 for range 来快速遍历可迭代对象，例如数组、切片、map、channel、字符串等。

对于切片、数组、字符串，其 for range 遍历方式有三种

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

// 遍历一：不关心索引和数据的情况
for range a {
}

// 遍历二：只关心索引的情况
for index := range a {
 fmt.Println(index)
}

// 遍历三：关心索引和数据的情况
for index, value := range a {
 fmt.Println(index, value)
}
```

map 也有三种  for range 遍历方式

```go
m := map[int]string{1: "Golang", 2: "Python", 3: "Java"}
// 遍历一：不关心 key 和 value 的情况
for range m {
}

// 遍历二：只关心 key 的情况
for key := range m {
 fmt.Println(key)
}

// 遍历二：关心 key 和 value 的情况
for key, value := range m {
 fmt.Println(key, value)
}
```

对于 channel，有两种 for range 遍历方式

```go
ch := make(chan int, 10)

// 遍历一：不关心 channel 数据
for range ch {
}

// 遍历二：关心 channel 数据
for data := range ch {
 fmt.Println(data)
}
```

Go 编译器会将不同的 for range 遍历方式转换成不同的控制逻辑，简化使用逻辑，使得程序员能够更方便地对可迭代对象进行遍历处理。

Go语法糖

发表评论取消回复

在线影视视频网站合集

js奇淫技巧（一）

常见的app scheme大全

uniapp图片未加载成功前处理方案,防止闪烁

浏览器console引入jq

记录不是:key出现的问题,Vue warn: Duplicate keys detected:“tab-XXX“. This may cause an update error.

经常不吃早饭会有什么后果

springboot整合kaptcha验证码

解决npm WARN config global `--global`, `--local` are deprecated. Use `--location=global` instead.

golang文本取出中间文本

Go语法糖

发表评论 取消回复

Go语法糖

发表评论取消回复