Go中的那些语法糖

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

成都创新互联客户idc服务中心,提供电信内江机房、成都服务器、成都主机托管、成都双线服务器等业务的一站式服务。通过各地的服务中心,我们向成都用户提供优质廉价的产品以及开放、透明、稳定、高性价比的服务,资深网络工程师在机房提供7*24小时标准级技术保障。

1. 短变量声明

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

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

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

需要注意几个规则

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

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

:= 代表引入一个新的变量,所以不能在同一作用域使用相同的 := 语句两次。

x := 1
x := 1 // 重复定义,错误

在多变量声明中,如果其中一个变量是新的,可以使用 := 两次

x, y := 1, 2
y, z := 3, 4 // z 是新的变量
x, z := 5, 6 // 错误,x、z 均已定义过

可以使用 := 在新的作用域中声明变量,即使该变量之前已经用相同的名称声明过。

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
}

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

2. new 函数

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

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

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

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

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

3. ...与切片

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

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

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

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

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

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

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

思考一下,如果让你初始化一个 int 切片,除了第 50 位值为 1,第 99 位值为2,其余位均为 0,你会如何定义?

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

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

4. 接收者方法

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

type Instance struct{}

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

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

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

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

type Instance struct{}

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

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

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

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

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

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

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

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

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

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 遍历方式

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 遍历方式

ch := make(chan int, 10)

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

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

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

总结

语法糖能让程序员使用更简练的言语表达较复杂的含义,它的本质是编译器做了额外的处理逻辑。

本文列出了 Go 的一些语法糖规则,童鞋们之前都了解吗?如有遗漏,欢迎补充~

本文标题:Go中的那些语法糖
本文链接:http://www.gawzjz.com/qtweb/news13/192513.html

网站建设、网络推广公司-创新互联,是专注品牌与效果的网站制作,网络营销seo公司;服务项目有等

广告

声明:本网站发布的内容(图片、视频和文字)以用户投稿、用户转载内容为主,如果涉及侵权请尽快告知,我们将会在第一时间删除。文章观点不代表本网站立场,如需处理请联系客服。电话:028-86922220;邮箱:631063699@qq.com。内容未经允许不得转载,或转载时需注明来源: 创新互联