fuchencong

The way I am

0%

Go 语言学习笔记（1）：初识 Go，类型与表达式

发表于 分类于

Go 语言自 C 一脉相承，又吸收了些时髦的东西。最重要的是，它依旧简单。本系列文章是《Go 语言学习笔记》一书的读书笔记。

Go 特征简介

  • 语法简单：Go 语言与 C99、C11 相似之处颇多，有时候被称为 NextC。Go 语言从 0 开始，没有历史包袱，在汲取众多经验教训后，可以从头规划一个规则严谨、条例简单的世界
  • 并发模型：Goruntime 是 Go 最为显著的特征，它用类似于协程的方式来处理并发单元，却又在运行时层面做了更深度的优化处理。这使得语法上的并发编程变得极为容易，无需处理回调，无须关注运行时切换，仅一个关键字，简单而自然。搭配 channel，实现 CSP 模型，将并发单元间的数据耦合解开，各司其职
  • 内存分配：Go 使用了 tcmalloc（为并发而设计的高性能内存分配组件）。除偶尔因性能问题而被迫采用对象池和自主内存管理外，基本无需参与内存管理操作
  • 垃圾回收：垃圾回收一直是一个难题，每次升级，垃圾回收器必然是核心组件里修改最多的部分。Go Team 一直在为好用的垃圾回收算法而努力
  • 静态链接：Go 刚发布时，静态链接被当做优点宣传，只需编译后的一个可执行文件，无需附加任何东西就能部署。将运行时、依赖库直接打包到可执行文件内部，简化了部署和发布操作。这种简单方式对于编写系统软件有着极大的好处，因为库依赖一直都是一个麻烦事
  • 标准库：功能完善、质量可靠的标准库为编程语言提供了充足动力。优秀的第三方资源也是语言生态圈的重要组成部分
  • 工具链：完整的工具链对日常开发极为重要，无论是编译、格式化、错误检查、帮助文档、还是第三方包下载、更新，都有对应的工具。内置完整的测试框架，包括单元测试、性能测试、代码覆盖率、数据竞争，以及用来调用的 pprof。除此之外，还可以通过环境变量输出运行时监控信息，尤其是垃圾回收和并发调度跟踪，可以帮助我们改进算法，获得更佳的运行器表现

初识 Go

源文件

  • 源文件使用 utf-8 编码，对 unicode 支持良好
  • 每个源文件都属于包的一部分，在文件头部用 package 声明所属包的名称
  • 以 .go 作为文件扩展名，语句结束分号会被默认省略
  • 支持 C 样式注释
  • 入口函数 main 没有参数，且必须放在 main 包中
  • 用 import 导入标准库或第三方包。如果导入某个包，但是没有使用，编译器会报错
  • 可以直接运行，或将源文件编译为可执行文件后运行

以下是 Go 语言的 hello, world：

1
2
3
4
5
6
7
package main

import "fmt"

func main() {
	fmt.Println("hello, world")
}
1
2
3
4
5
6
7
$ ls
test.go
$ go run test.go
hello, world
$ go build test.go
$ ./test
hello, world

变量

  • 使用 var 定义变量，支持类型推断
  • 基础数据类型划分清晰明确，有助于编写跨平台应用
  • 编译器确保变量总是被初始化为零值，避免出现意外情况
  • 在函数内部，还可以省略 var 关键字，使用更简单的定义模式
  • 编译器将未使用的局部变量定义为错误
1
2
3
4
5
6
7
8
package main

func main() {
	var x int32
	var s = "hello, world"
	y := 100
	println(x, y, s)
}

表达式

Go 仅有三种流控制语句：

  • if 语句
1
2
3
4
5
6
7
8
9
10
11
12
13
package main

func main() {
	x := 100

	if x > 0 {
		println(x)
	} else if x < 0 {
		println(-x)
	} else {
		println(0)
	}
}
  • switch 语句
1
2
3
4
5
6
7
8
9
10
11
12
13
14
package main

func main() {
	x := 100

	switch {
	case x > 0:
		println(x)
	case x < 0:
		println(-x)
	default:
		println(0)
	}
}
  • for 语句
1
2
3
4
5
6
7
package main

func main() {
	for i := 0; i < 5; i++ {
		println(i)
	}
}

在迭代遍历时，for…range 除元素外，还可以返回索引

1
2
3
4
5
6
7
8
9
package main

func main() {
	x := []int{100, 101, 102}

	for i, n := range x {
		println(i, ":", n)
	}
}

函数

  • 函数可以定义多个返回值，甚至对其命名
1
2
3
4
5
6
7
func div(a, b int) (int, error) {
	if b == 0 {
		return 0, errors.New("division by zero")
	}

	return a / b, nil
}
  • 函数是第一类型，可以将其作为参数或者返回值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
package main

func test(x int) func() {
	return func() {
		println(x)
	}
}

func main() {
	x := 100

	f := test(x)
	f()
}
  • 用 defer 定义延迟调用，无论函数是否出错，它都确保结束前被调用
1
2
3
4
5
6
7
8
9
10
package main

func test(a, b int) {
	defer println("dispose...")
	println(a / b)

}
func main() {
	test(10, 0)
}

数据

  • 切片实现类似动态数组的功能
1
2
3
4
5
6
7
8
9
10
11
12
13
package main

import "fmt"

func main() {
	x := make([]int, 0, 5)

	for i := 0; i < 8; i++ {
		x = append(x, i)
	}

	fmt.Println(x)
}
  • 将字典类型内置，可从运行时层面获得性能优化
1
2
3
4
5
6
7
8
9
10
11
12
13
package main

import "fmt"

func main() {
	m := make(map[string]int)

	m["a"] = 1
	x, ok := m["b"]
	fmt.Println(x, ok)

	delete(m, "a")
}

  • 上一个例子中使用了 ok-idiom 模式，在多个返回返回值中使用一个名为 ok 的布尔值来表示操作是否成功。因为很多操作默认都返回零值，所以需要额外说明

  • 结构体可以匿名嵌入其他类型，然后直接访问匿名字段的成员

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package main

import "fmt"

type user struct {
	name string
	age  byte
}

type manager struct {
	user
	title string
}

func main() {
	var m manager

	m.name = "Tom"
	m.age = 29
	m.title = "CTO"

	fmt.Println(m)
}

方法

  • 可以为当前包内的任意类型定义方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main

import "fmt"

type X int

func (x *X) inc() {
	*x++
}

func main() {
	var x X
	x.inc()
	fmt.Println(x)
}
  • 可以直接调用匿名字段的方法，这种方式可实现与继承类似的功能
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package main

import "fmt"

type user struct {
	name string
	age  byte
}

func (u user) ToString() string {
	return fmt.Sprintf("%+v", u)
}

type manager struct {
	user
	title string
}

func main() {
	var m manager

	m.name = "Tom"
	m.age = 29
	m.title = "CTO"

	fmt.Println(m.ToString())
}

接口

  • 接口采用了 duck type，也就是说无须在实现类型上添加显式声明
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package main

import "fmt"

type user struct {
	name string
	age  byte
}

func (u user) Print() {
	fmt.Printf("%+v\n", u)
}

type Printer interface {
	Print()
}

func main() {
	var m user

	m.name = "Tom"
	m.age = 29

	var p Printer = m
	p.Print()
}
  • 空接口类型 interface{} 类似于 OOP 里的 Object 类型，可以接收任意类型对象

并发

  • 整个运行时完全并发设计，凡是你能看到的，几乎都在以 goroutine 方式运行
  • 这是一种比普通线协程或线程更加高效的设计，能够轻松创建和运行成千上万的并发任务
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package main

import (
	"fmt"
	"time"
)

func task(id int) {
	for i := 0; i < 5; i++ {
		fmt.Printf("%d: %d\n", id, i)
		time.Sleep(time.Second)
	}
}

func main() {
	go task(1)
	go task(2)

	time.Sleep(time.Second * 6)
}
  • 通道（channel）与 goroutine 搭配，实现用通信代替内存共享的 CSP 模型
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package main

func consumer(data chan int, done chan bool) {
	for x := range data {
		println("recv:", x)
	}

	done <- true
}

func producer(data chan int) {
	for i := 0; i < 4; i++ {
		data <- i
	}

	close(data)
}

func main() {
	done := make(chan bool)
	data := make(chan int)

	go consumer(data, done)
	go producer(data)

	<-done
}

类型

变量

从计算机的角度来看，变量是一段或多段用来存储数据的内存。作为静态数据类型语言，Go 变量总是有固定的数据类型，类型决定了变量内存的长度和存储格式，只能修改变量的值，无法改变类型。实际上，编译后的机器码从不使用变量名，而是直接通过内存地址来访问目标数据。保存在符号表中的变量名等信息可以被删除，或用于输出更详细的错误信息。

变量的定义

  • 关键字 var 用于定义变量，类型被放置于变量名之后。另外运行时内存分配操作会确保变量自动初始化为该类型的零值，避免出现不可预测的行为
1
var x int
  • 如果显式提供初始值，可省略变量类型，由编译器推断
1
var y = false
  • 可一次定义多个变量，包括用不同初始值定义不同类型
1
2
var x, y int
var a, s = 100, "abc"
  • 依照惯例，建议以多组方式整理多行变量定义
1
2
3
4
var (
    x, y int
    a, s = 100, "abc"
)
  • 除 var 关键字外，还可以使用更加简短的变量定义和初始化语法。简短定义在函数多返回值，以及 if/for/switch 等语句中定义局部变量非常方便
1
2
x := 100
a, s := 1, "abc"

简短模式有些限制：

1： 定义变量，同时显式初始化
2：不能提供数据类型
3：只能用在函数内部

需要注意，简短模式并不总是重新定义变量，也可能是部分退化的赋值操作。

1
2
3
4
5
6
7
8
9
10
package main

func main() {
	x := 100
	println(&x, x)

	x, y := 200, "abc"
	println(&x, x)
	println(&y, y)
}
1
2
3
4
$ ./short_var
0xc00003a760 100
0xc00003a760 200
0xc00003a768 abc

退化赋值的前提条件是：最少有一个新变量被定义，且必须是同一作用域。以下两种情况都不是退化赋值：

1
2
3
4
5
6
7
8
9
package main

func main() {
	x := 100
	println(&x, x)

	x := 200
	println(&x, x)
}
1
2
3
$ go build short_var_err1.go
# command-line-arguments
./short_var_err1.go:7:4: no new variables on left side of :=
1
2
3
4
5
6
7
8
9
10
11
12
13
package main

func main() {
	x := 100
	println(&x, x)

	{
		x, y := 200, "abc"
		println(&x, x)
		println(&y, y)
	}

}
1
2
3
4
$ ./short_var_err2
0xc00003a760 100
0xc00003a758 200
0xc00003a768 abc

在处理函数错误返回值时，退化赋值允许我们重复使用 err 变量，这简化了代码的写法。

多变量赋值

  • 在进行多变量赋值操作时，首先计算出所有右值，然后再依次完成赋值操作
  • 赋值操作，必须确保左右值类型相同

未使用错误

  • 编译器将未使用的局部变量当做错误，这有助于培养良好的编码习惯

命名

对变量、常量、函数、自定义类型进行命名，通常优先选用有实际含义，易于阅读和理解的字母或单词组合。命名建议：

  • 以字母或下划线开始，由字母、数字、下划线构成
  • 区分大小写
  • 使用驼峰拼写格式
  • 局部变量优先使用短名
  • **不要使用保留关键字
  • 不建议使用与预定义常量、类型、内置函数相同的名字
  • 专有名词通常会全部大写

符号名字首字母大小写决定了其作用域，首字母大写的为导出成员，可以被外部包引用，而小写则仅能在包内使用。c

Go 提供了一个名为 _ 的特殊成员，通常用作忽略占位符使用，可用作表达式左值，无法读取内容。空标识符可用来临时规避编译器对未使用变量和导入包的错误检查。空标识符是预置成员，不能重新定义。

常量

常量表示运行时恒定不可变的值，通常是一些字面量。常量值必须是编译器可确定的字符、字符串、数字和布尔值。可指定常量类型，或由编译器通过初始化值推断，不支持 C/C++ 数字类型后缀。未曾使用的常量不会引发编译错误。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package main

const x, y int = 123, 0x22
const s = "hello, world"

const (
	i, f = 1, 0.123
	b    = false
)

const (
	m, n int  = 99, -99
	p    byte = byte(m)
	q         = uint8(n)
)

func main() {
	const x = 123
}

如果显式指定类型，必须确保常量的左右值类型一致，需要时可以做显式转换。右值不能超过常量类型取值范围，否则会引发溢出错误。

1
2
3
4
5
const (
	m, n int  = 99, -99
	p    byte = byte(m)
	q         = uint8(n)    //  constant -99 overflows uint8
)

常量值也可以是某些编译器能计算出结果的表达式，如 unsafe.Sizeof, len, cap 等。

在常量组中，如果不指定类型和初始化值，则与上一行非空常量右值相同。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package main

import "fmt"

const (
	x uint16 = 120
	y
	s = "abc"
	z
)

func main() {
	fmt.Println(x, y, s, z)
}

枚举

Go 并没有明确意义上的 enum 定义，但是通过 itoa 标识符可以实现一组自增常量值，从而实现枚举类型。iota 的值是当前常量表达式在常量组中的索引，从 0 开始计数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package main

import "fmt"

const (
	x = iota
	y
	z
)

const (
	_  = iota
	KB = 1 << (10 * iota)
	MB
	GB
)

func main() {
	fmt.Println(x, y, z)
	fmt.Println(KB, MB, GB)
}

可以在多常量定义中使用多个 iota，它们各自单独计数，只需要保证每行常量的列数量相同即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package main

import "fmt"

const (
	_, _ = iota, iota * 10
	a, b = iota, iota * 10
	c, d = iota, iota * 10
)

func main() {
	fmt.Println(a, b)
	fmt.Println(c, d)
}

如果中断 iota，必须显式恢复。且恢复后的枚举值仍按行序递增（而不是从上一个值开始递增）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package main

import "fmt"

const (
	a = iota
	b
	c = 100
	d
	e = iota
	f
)

func main() {
	fmt.Println(a, b, c, d, e, f)
}

在实际编码中，建议使用自定义类型实现用途明确的枚举类型。但这并不能将取值范围限定在预定义的枚举值内：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package main

type color byte

const (
	black color = iota
	red
	blue
)

func test(c color) {
	println(c)
}

func main() {
    test(red)
    // compile error
	test(100)

    // compile error
	x := 2
	test(x)
}

常量小结

  • 不同于变量在运行期分配存储内存（非优化状态），常量通常会被编译器在预处理阶段直接展开，作为指令数据使用
  • 数字常量不会分配存储空间，无须像变量那样通过内存寻址来取值，因此无法获取地址
  • 另外定义常量时，是否指定类型也会对编译器产生影响
1
2
3
4
5
6
7
8
9
10
11
12
13
14
package main

func main() {
    const x = 100
    // ok
	const y byte = x

	println(x, y)

	const a int = 100
    // compile error
	const b byte = a
	println(a, b)
}
1
2
3
$ go build const3.go
# command-line-arguments
./const3.go:10:8: cannot use a (type int) as type byte in const initializer

基本类型

清晰完备的预定义基础类型，使得开发跨平台应用时无需过多考虑符号和长度差异。

类型 长度 默认值
bool 1 false
byte 1 0
int, uint 4 / 8 0
int8, uint8 1 0
int16, uint16 2 0
int32, uint32 4 0
int64, uint64 8 0
float32 4 0.0
float64 8 0.0
complex64 8
complex128 16
rune 4 false
uintptr 4 / 8 0
string “”
array
struct
function nil
interface nil
map nil
slice nil
channel nil
  • 支持八进制、十六进制以及科学计数法，标准库 math 定义了各数字类型的取值范围
  • 标准库 strconv 可以在不同进制（字符串）间转换
  • 使用浮点数时，需要注意小数位的有效精度问题

别名

byte 其实是 uint8 的别名，而 rune 则是 uint32 的别名。别名类型无须转换，可直接赋值。但是这并不表示，拥有相同底层结构的就属于别名。例如在 64 位体系结构中，int 和 int64 底层结构完全相同，但是分属于不同类型，需显式转换。

引用类型

所谓引用类型，特指 slice、map、channel 这三种预定义类型。相比数字、数组等类型，引用类型拥有更复杂的存储结构，除分配内存外，它们还需要初始化一系列属性，例如指针、长度等。

内置函数 new 按照指定类型长度分配内存（内存中填充该类型的零值），返回指针，它并不关心类型内部构造和初始化方式。而引用类型则必须使用 make 函数创建，编译器会将 make 转换为目标类型专用的创建函数，以确保完成全部内存分配和相关属性初始化。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package main

func mkslice() []int {
	s := make([]int, 0, 10)
	s = append(s, 100)
	return s
}

func mkmap() map[string]int {
	m := make(map[string]int)
	m["a"] = 1
	return m
}

func main() {
	m := mkmap()
	println(m["a"])

	s := mkslice()
	println(s[0])
}

类型转换

隐式转换造成的问题远远大于它所带来的好处。除常量、别名类型以及未命名类型外，Go 强制要求使用显式转换。加上不支持操作符重载，所以总是能确定语句及表达式的明确含义。同样，不能把非 bool 类型结果当做 true/false 使用。

如果转换的目标是指针、单向通道或者没有返回值的函数类型，必须使用括号，以避免造成语法分解错误。

1
2
3
x := 100
p := *int(&x)  // error
p := (*int)(&x) // ok

自定义类型

使用关键字 type 定义用户自定义类型，包括基于现有基础类型创建，或者是结构体、函数类型等。和 var、const 一样，多个 type 定义可以合并成组，可以在函数或代码块内定义局部类型。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package main

import "fmt"

type flags byte

const (
	read flags = 1 << iota
	write
	exec
)

func main() {
	f := read | exec
	fmt.Printf("%b", f)
}

即便指定了基础类型，也只表明它们拥有相同的底层数据结构，两者之间不存在任何关系，属于两种完全不同的类型。除操作符外，自定义类型不会继承基础类型的其他信息（包括方法）。不能视作别名，不能隐式转换，不能直接用于比较表达式。

1
2
3
4
5
6
7
8
9
10
package main

func main() {
	type data int
	var d data = 10

    // compile error
	var x int = d
	println(d)
}
1
./data.go:7:6: cannot use d (type data) as type int in assignment

与有明确标识符的 bool、int、string 等类型相比，数组、切片、字典、通道等类型与具体元素类型或长度等属性有关，因此称为未命名类型。可以用 type 为其提供具体名称，将其改变为命名类型。具有相同声明的未命名类型被视为同一类型：

  • 具有相同基类型的指针
  • 具有相同元素类型和长度的数组
  • 具有相同元素类型的切片
  • 具有相同键值类型的字典
  • 具有相同数据类型及操作方向的通道
  • 具有相同字段序列（字段名、字段类型、标签以及字段顺序）的结构体
  • 具有相同签名（参数和返回值列表，不包括参数名）的函数
  • 具有相同方法集（方法名、方法签名，不包括顺序）的接口

未命名类型的转换规则如下：

  • 所属类型相同
  • 基础类型相同，且其中一个是未命名类型
  • 数据类型相同，将双向通道赋值给单向通道，且其中一个为未命名类型
  • 将默认值 nil 赋值给切片、字典、通道、指针、函数或接口
  • 对象实现了目标接口

表达式

保留字

Go 语言仅包含 25 个保留关键字，这体现了 Go 语法规则的简洁性。

运算符

运算符和表达式用来串联数据和指令，算是最基础的算法。一元运算符的优先级最高，二元则分成 5 个级别，从高到低分别是：

1：* / % << >> & &^
2：+ - | ^
3：== != < <= > >=
4：&&
5：||

相同优先级的二元运算符，从左往右依次计算。对于二元运算符而言，操作数类型必须相同，如果其中一个是无显式类型声明的常量，那么该常量操作数会自动转型。

  • 位移右操作数必须是无符号整数，或者可以转换的无显式类型常量。如果是非常量位移表达式，那么会优先将无显式类型的常量左操作数转型：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
package main

import "fmt"

func main() {
	a := 1.0 << 3
	fmt.Printf("%T, %v\n", a, a)

	var s uint = 3
	b := 1.0 << s

	var c int32 = 1.0 << s
	fmt.Printf("%T, %v\n", c, c)
}
1
2
# command-line-arguments
./shift.go:10:4: invalid operation: 1 << s (shift of type float64)

  • 二进制位运算符比较特别的是 bit clear，即 &^，例如 1011 &^ 1101 = 0010。

  • 自增、自减不再是运算符，只能作为独立语句，不能用于表达式（表达式通常是求值代码，可作为右值或参数使用，而语句完成一个行为。表达式可以作为语句使用，而语句却不能作为表达式使用）。

  • 不能将内存地址和指针混淆。内存地址是内存中每个字节单元的唯一编号，而指针则是一个实体。指针会分配内存空间，相当于一个专门用来保存地址的整型变量。取地址运算符 & 用于获取对象的地址，而指针运算符 * 用于间接引用目标对象。

  • 并非所有对象都能进行取地址操作，变量总是可寻址的。指针类型支持相等运算符，但不能做加减运算和类型转换。如果两个指针指向同一个地址，或者都为 nil，那么它们相等。

  • 可通过 unsafe.Pointer 将指针转换为 uintptr 后进行加减运算，但可能会造成非法访问。unsafe.Pointer 类似于 C 语言中的 void*，可用来转换指针类型，它能安全地持有对象或对象成员，但 uintptr 不行。后者仅仅是一种特殊整型，并不引用目标对象，无法阻止垃圾回收器回收对象内存

  • 指针没有专门指向成员的 -> 运算符，统一使用 . 表达式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package main

func main() {
	type user struct {
		name string
		age  int
	}

	u := user{
		name: "Jack",
		age:  10,
	}

	p := &u
	println(p.name, p.age)
}
  • 零长度对象的地址是否相等和具体的实现相关，但是肯定不等于 nil。

初始化

对复合类型（数组、切片、字典、结构体）变量初始化时，有一些语法限制：

  • 初始化表达式必须包含类型标签
  • 左花括号必须在类型尾部，不能另起一行
  • 多个成员初始值以逗号分隔
  • 允许多行，但每行以逗号或者右花括号结束

流控制

if…else 中的条件表达式必须是布尔类型，可省略括号，且左花括号不能另起一行。比较特别的是对初始化语句的支持，可定义块局部变量（有效范围包含整个 if/else 块）或执行初始化函数。

与 if 类似，switch 语句也用于选择执行，但具体使用的场景会有所不同。条件表达式支持非常量，这要比 C 更加灵活。switch 同样支持初始化语句，按照从上到下，从左到右的顺序匹配 case 执行。只有全部匹配失败时，才会执行 default 块。无须显式执行 break 语句，case 执行完毕后自动中断。如须贯通后续 case，须执行 fallthrough，但不再匹配后续条件表达式。注意，fallthrough 必须放在 case 块结尾，可使用 break 语句阻止。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package main

func main() {
	a, b, c, x := 1, 2, 3, 2

	switch x {
	case a, b:
		println("a | b")
	case c:
		println("c")
	case 4:
		println("d")
	default:
		println("z")
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main

func main() {
	switch x := 5; x {
	default:
		println(x)
	case 5:
		x += 10
		println(x)
		fallthrough
	case 6:
		x += 20
		println(x)
	}
}

需要注意，相邻的空 case 不构成多条件匹配，此时仅表示相应的 case 内容为空。另外，不能出现重复的 case 常量值。

有些时候，switch 还被用来替换 if 语句，被省略的 switch 条件表达式默认为 true，继而与 case 表达式结果匹配：

1
2
3
4
5
6
7
8
9
10
11
12
package main

func main() {
	switch x := 5; {
	case x > 5:
		println("a")
	case x > 0 && x <= 5:
		println("b")
	default:
		println("z")
	}
}

仅有 for 一种循环语句，但是常用方式都支持。初始化语句仅被执行一次。

1
2
3
4
5
6
7
8
9
10
11
for i := 0; i < 3; i++ {

}

for x < 10 {
    x++
}

for {
    break
}

可用 for...range 完成数据迭代，支持字符串、数组、数组指针、切片、字典、通道类型，返回索引、键值数据：

1
2
3
4
5
6
7
8
9
package main

func main() {
	data := [3]string{"a", "b", "c"}

	for i, s := range data {
		println(i, s)
	}
}

不同于 Python，在 Go 中没有相关接口实现自定义迭代类型，除非基础类型就是以上类型之一。

无论普通 for 循环，还是 range 迭代，其定义的局部变量都会重复使用。另外需要注意，range 会复制目标数据，受直接影响的是数组，可改用数组指针或切片类型。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package main

import "fmt"

func main() {
	data := [3]int{10, 20, 30}

	for i, x := range data {
		if i == 0 {
			data[0] += 100
			data[1] += 200
			data[2] += 300
		}

		fmt.Printf("x: %d data: %d\n", x, data[i])
	}

	for i, x := range data[:] {
		if i == 0 {
			data[0] += 100
			data[1] += 200
			data[2] += 300
		}
		fmt.Printf("x: %d data: %d\n", x, data[i])
	}
}

运行结果：

1
2
3
4
5
6
7
 ./range
x: 10 data: 110
x: 20 data: 220
x: 30 data: 330
x: 110 data: 210
x: 420 data: 420
x: 630 data: 630

如果 range 目标表达式是函数调用，也仅被执行一次。

使用 goto 前，必须先定义标签，标签区分大小写，且未使用的标签会引发编译错误。且不能跳转到其他函数或者内层代码块内。和 goto 定点跳转不同，break、continue 用于中断代码块执行：

  • break：用于 swtich、for、select 语句，终止整个语句块执行
  • continue：仅用于 for 循环，终止后续逻辑，立即进入下一轮循环

配合标签，break 和 continue 可在多层嵌套中指定目标层级：

1
2
3
4
5
6
7
8
9
10
11
12
package main

func main() {
outer:
	for x := 0; x < 5; x++ {
		println("loop exec", x)

		if x > 2 {
			break outer
		}
	}
}
1
2
3
4
5
$ ./break_label
loop exec 0
loop exec 1
loop exec 2
loop exec 3