上一篇：函数
下一篇：单元测试

---

1. 条件语句

Go语言中，条件语句分为三种：if语句、switch语句和select语句。

1.1. if…else 语句

if语句基本格式如下：

if 条件 {// 条件满足时执行的语句
} else if 条件 {// 条件满足时执行的语句
} else {// 条件为false时执行的语句
}

不支持三元操作符(三目运算符) ：“a > b ? a : b”

1.2. switch 语句

基于不同的条件执行不同的动作，每个case分支都是唯一的，从上至下逐一匹配，直到匹配到一个case分支，执行该分支的代码，并终止匹配。

switch语句基本格式如下：

switch 值 {
case 值1:// 值等于值1时执行的语句
case 值2:// 值等于值2时执行的语句
default:// 值不等于值1和值2时执行的语句
}

• 如果switch没有表达式，它会匹配true。
• case 分支表达式可以是任意类型，不限于常量，但必须是相同类型
• 一个 case 可以同时测试多个值，用逗号分隔。例如：case val1, val2, val3:
• 一个 case 分支可以使用fallthrough语句，匹配成功后强制执行相邻的下一个case语句，且fallthrough不可使用在最后一个分支。
• Go语言的switch默认相当于每个case最后带有break，可省略。

示例：

package mainimport "fmt"func main() {var i = 0switch i {case 0:println("0")    println("fallthrough")  // 使用fallthrough语句，匹配成功后强制执行下一个case代码：case 1,2fallthroughcase 1, 2:  // 一个 case 可以同时测试多个值，用逗号分隔。fmt.Println("1 或 2")case 3:fmt.Println("3")default:fmt.Println("default")// fallthrough  // fallthrough不可使用在最后一个分支}// 输出结果：// 0// fallthrough// 1 或 2var n = 6switch { //省略条件表达式默认为true，可当 if...else if...elsecase n > 0 && n < 10:fmt.Println("i > 0 and i < 10")case n > 10 && n < 20:fmt.Println("i > 10 and i < 20")default:fmt.Println("def")}// 输出结果：// i > 0 and i < 10
}

1.3. select 语句

select是Go中的一个控制结构，类似 switch 语句，用于处理异步IO操作。但是select用于等待多个通信操作的完成，会随机执行一个可运行的case；如果没有case可运行，它将阻塞，直到有case可运行。

1.3.1. select 语句的通信表达式

• 一个通信操作，如：ch <- v 或 v := <-ch
• 一个接收表达式，如：v := <-ch
• 一个发送表达式，如：ch <- v
• 一个默认通信，如：default

1.3.2. select 的基特性

• case 语句必须是一个 cannel 操作，要么是发送，要么是接收。
• select 中 default 语句总是可执行的（一般不写在里面，因为会很消CPU资源）。
• 如果任意某个通信可以执行，它就执行；其它被忽略。
• 如果有多个 case 都可以运行，select 会随机公平地选出一个执行；其它不会执行。
• 如果没有可运行的 case 语句，且有 default 语句，那么就会执行 default 的动作。
• 如果没有可运行的 case 语句，且没有 default 语句，select 将阻塞，直到某个 case 通信可以运行。

1.3.3. select 的实现原理

参考：Go select 底层原理、select 的随机公平策略理

无 case 永久堵塞

select{} // fatal error: all goroutines are asleep - deadlock!
// 
// goroutine 1 [select (no cases)]:

select 所有 case 均无法执行且没有 default，则阻塞

ch := make(chan struct{})
select {
case data <- ch:  // 只有一个 case，实际会被编译器转换为相应 channel 相应的收发操作，其实和实际调用 data := <- ch 并没有什么区别fmt.Printf("ch data: %v\n", data)
}// fatal error: all goroutines are asleep - deadlock!
// 
// goroutine 1 [chan receive]:

select多个case同时可以执行，随机选择一个去执行

package mainimport "fmt"func main() {var c1 = make(chan int, 2)c2 := make(chan string, 2)c3 := make(chan int, 2)var i1 inti2 := "two"c1 <- 1c2 <- "one"c3 <- 3select {case i1 = <-c1:fmt.Printf("received %d from c1\n", i1)case c2 <- i2:fmt.Printf("send %s to c2\n", i2)case i3, ok := <-c3: // same as: i3, ok := (<-c3)if ok {fmt.Printf("received %d from c3\n", i3)} else {fmt.Printf("c3 is closed\n")}default:fmt.Printf("no communication\n")}
}
//随机输出下面一条：
// send two to c2
// received 1 from c1
// received 3 from c3

1.3.4. 经典用法

1.3.4.1 超时控制

package mainimport ("fmt""time"
)func main() {ch := make(chan int)go func() {time.Sleep(3 * time.Second)ch <- 1}()select {case data, ok := <-ch:if ok {fmt.Println("接收到数据: ", data)} else {fmt.Println("通道已被关闭")}case <-time.After(2 * time.Second):fmt.Println("超时了！")}
}// 超时了！

1.3.4.2 多任务并发控制

package mainimport ("fmt"
)func main() {ch := make(chan int)for i := 0; i < 10; i++ {go func(id int) {ch <- id}(i)}for i := 0; i < 10; i++ {select {case data, ok := <-ch:if ok {fmt.Println("任务完成：", data)} else {fmt.Println("通道已被关闭")}}}
}// 每次执行，顺序不一致
// 任务完成： 2
// 任务完成： 0
// 任务完成： 1
// 任务完成： 4
// 任务完成： 3
// 任务完成： 6
// 任务完成： 5
// 任务完成： 7
// 任务完成： 8
// 任务完成： 9

1.3.4.3 监听多通道消息

package mainimport ("fmt""time"
)func main() {ch1 := make(chan int)ch2 := make(chan int)// 开启 goroutine 1 用于向通道 ch1 发送数据go func() {for i := 0; i < 5; i++ {ch1 <- itime.Sleep(time.Second)}}()// 开启 goroutine 2 用于向通道 ch2 发送数据go func() {for i := 5; i < 10; i++ {ch2 <- itime.Sleep(time.Second)}}()// 主 goroutine 从 ch1 和 ch2 中接收数据并打印for i := 0; i < 10; i++ {select {case data := <-ch1:fmt.Println("Received from ch1:", data)case data := <-ch2:fmt.Println("Received from ch2:", data)}}fmt.Println("Done.")
}

1.3.4.4 default 实现非堵塞读写

import ("fmt""time"
)func main() {ch := make(chan int, 1)go func() {for i := 1; i <= 5; i++ {ch <- itime.Sleep(1 * time.Second)}close(ch)}()for {select {case val, ok := <-ch:if ok {fmt.Println(val)} else {ch = nil}default:fmt.Println("No value ready")time.Sleep(500 * time.Millisecond)}if ch == nil {break}}
}

2. 循环语句

2.1. for 语句

Go语言 for 循环有 3 种形式。

for init; condition; post{}
for condition {}
for {}

示例：

package mainimport "fmt"func main() {for i := 0; i < 10; i++ {fmt.Println("i =", i)}fmt.Println()n := 10for n > 0 {fmt.Println("n =", n)n--}fmt.Println()j := 0for {if j >= 10 {break}fmt.Println("j =", j)j++}fmt.Println()
}

2.2. for … range

range 类似迭代器操作，返回（索引, 值）或（键, 值）。

for ... range 格式可以对 slice、map、数组、字符串等进行迭代循环。格式如下：

for key, value := range oldMap {}

示例：

package mainimport "fmt"func main() {s := "string中文"for i, v := range s {fmt.Printf("%d, %d, %T\n", i, v, v)}println()// 忽略值for i := range s {fmt.Printf("%d\n", i)}// 忽略返回值，仅迭代for range s {}println()println()a := [3]int{0, 1, 2}for i, v := range a {if i == 0 {a[1], a[2] = 222, 333 // range 会复制对象，修改 a 不影响 i, v 的值}fmt.Println(i, v, a) // 输出：[0 222 333]a[i] = 100 + v}fmt.Println(a) // 输出：[100 101 102]println()println()si := []int{1, 2, 3, 4, 5}for i, v := range si {if i == 0 {si = si[:3] // 对 slice 的修改，不会影响 rangesi[2] = 100 // 对底层数据的修改，影响 range}fmt.Printf("%d, %d, %v\n", i, v, si)}
}

for...range 可以遍历 channel， 与遍历 map、slice 不同

package mainimport "fmt"func main() {queue := make(chan string, 2)for i := 0; i < 10; i++ {queue <- "-data-" + strconv.Itoa(i)}close(queue)// 这个 `range` 迭代从 `queue` 中得到的每个值。// 因为我们在前面 `close` 了这个通道，这个迭代会在接收完 queue 中的值之后结束；for elem := range queue {fmt.Println(elem)}// 如果我们没有 `close` 它，我们将在这个循环中继续阻塞执行，等待接收下一个个值。类似下面代码 for {}for {fmt.Println(<- queue)}
}

3. goto、break、continue

break：跳出循环。
continue：跳过当前循环，继续下一次循环。仅限 for 循环内使用。
goto：通过label跳转到指定位置。

• 三个标签都可以配合标签（label）使用。
• continue, break 配合标签可用于多层循环跳出。
• goto 是调整执行位置，跳到指定标签代码块执行；continue 配合标签为跳到指定循环继续执行, break 配合标签跳出指定标签代码块的循环。

package mainimport "Learing/demo"func main() {// 标签区名分大小写，若定义标签不使用则会照成编译错误。
LabelBreak: // break 的跳转标签放在循环语句前面for {for i := 0; i < 10; i++ {if i > 2 {break LabelBreak // break, 跳出 LabelBreak 标签代码块，不再执行循环}fmt.Println("break -", i)}}fmt.Println()LableContinue:  // continue 的跳转标签放在循环语句前面for i := 0; i < 5; i++ {for {fmt.Println("before", i)continue LableContinue // continue, 跳到LableContinue标签的循环，继续执行循环。fmt.Println("after")}}fmt.Println("continue label")fmt.Println()for {for i := 0; i < 10; i++ {if i > 2 {goto LabelGoto // goto, 跳转到指定标签代码块}fmt.Println("goto -", i)}}
LabelGoto:fmt.Println("goto label")fmt.Println()
}func SelectBreak() {ch := make(chan int, 2)go func() {for i := 0; i < 10; i++ {ch <- i}}()Label:for {select {case v, ok := <-ch:fmt.Println(ok, v)if v == 5 {break Label // 在 for 的 select 体中 break 到外层循环}default:fmt.Println("The ch value is not ready.")time.Sleep(500 * time.Millisecond)}}fmt.Println("Break for select")
}