流程控制
- [1. 条件语句](#1. 条件语句)
-
- [1.1. if...else 语句](#1.1. if...else 语句)
- [1.2. switch 语句](#1.2. switch 语句)
- [1.3. select 语句](#1.3. select 语句)
-
- [1.3.1. select 语句的通信表达式](#1.3.1. select 语句的通信表达式)
- [1.3.2. select 的基特性](#1.3.2. select 的基特性)
- [1.3.3. select 的实现原理](#1.3.3. select 的实现原理)
- [1.3.4. 经典用法](#1.3.4. 经典用法)
-
- [1.3.4.1 超时控制](#1.3.4.1 超时控制)
- [1.3.4.2 多任务并发控制](#1.3.4.2 多任务并发控制)
- [1.3.4.3 监听多通道消息](#1.3.4.3 监听多通道消息)
- [1.3.4.4 default 实现非堵塞读写](#1.3.4.4 default 实现非堵塞读写)
- [2. 循环语句](#2. 循环语句)
-
- [2.1. for 语句](#2.1. for 语句)
- [2.2. for ... range](#2.2. for ... range)
- [3. goto、break、continue](#3. goto、break、continue)
1. 条件语句
Go语言中，条件语句分为三种：if语句、switch语句和select语句。
1.1. if...else 语句
if语句基本格式如下：
go
if 条件 {
// 条件满足时执行的语句
} else if 条件 {
// 条件满足时执行的语句
} else {
// 条件为false时执行的语句
}不支持三元操作符(三目运算符) ："a > b ? a : b"
1.2. switch 语句
基于不同的条件执行不同的动作，每个case分支都是唯一的，从上至下逐一匹配，直到匹配到一个case分支，执行该分支的代码，并终止匹配。
switch语句基本格式如下：
go
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，可省略。
示例：
go
package main
import "fmt"
func main() {
var i = 0
switch i {
case 0:
println("0")
println("fallthrough") // 使用fallthrough语句，匹配成功后强制执行下一个case代码：case 1,2
fallthrough
case 1, 2: // 一个 case 可以同时测试多个值，用逗号分隔。
fmt.Println("1 或 2")
case 3:
fmt.Println("3")
default:
fmt.Println("default")
// fallthrough // fallthrough不可使用在最后一个分支
}
// 输出结果：
// 0
// fallthrough
// 1 或 2
var n = 6
switch { //省略条件表达式默认为true，可当 if...else if...else
case 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 永久堵塞
go
select{}
// fatal error: all goroutines are asleep - deadlock!
//
// goroutine 1 [select (no cases)]:select 所有 case 均无法执行且没有 default，则阻塞
go
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同时可以执行，随机选择一个去执行
go
package main
import "fmt"
func main() {
var c1 = make(chan int, 2)
c2 := make(chan string, 2)
c3 := make(chan int, 2)
var i1 int
i2 := "two"
c1 <- 1
c2 <- "one"
c3 <- 3
select {
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 c31.3.4. 经典用法
1.3.4.1 超时控制
go
package main
import (
"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 多任务并发控制
go
package main
import (
"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
// 任务完成： 91.3.4.3 监听多通道消息
go
package main
import (
"fmt"
"time"
)
func main() {
ch1 := make(chan int)
ch2 := make(chan int)
// 开启 goroutine 1 用于向通道 ch1 发送数据
go func() {
for i := 0; i < 5; i++ {
ch1 <- i
time.Sleep(time.Second)
}
}()
// 开启 goroutine 2 用于向通道 ch2 发送数据
go func() {
for i := 5; i < 10; i++ {
ch2 <- i
time.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 实现非堵塞读写
go
import (
"fmt"
"time"
)
func main() {
ch := make(chan int, 1)
go func() {
for i := 1; i <= 5; i++ {
ch <- i
time.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 种形式。
go
for init; condition; post{}
for condition {}
for {}示例：
go
package main
import "fmt"
func main() {
for i := 0; i < 10; i++ {
fmt.Println("i =", i)
}
fmt.Println()
n := 10
for n > 0 {
fmt.Println("n =", n)
n--
}
fmt.Println()
j := 0
for {
if j >= 10 {
break
}
fmt.Println("j =", j)
j++
}
fmt.Println()
}2.2. for ... range
range 类似迭代器操作，返回（索引, 值）或（键, 值）。
for ... range 格式可以对 slice、map、数组、字符串等进行迭代循环。格式如下：
go
for key, value := range oldMap {
}示例：
go
package main
import "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 的修改，不会影响 range
si[2] = 100 // 对底层数据的修改，影响 range
}
fmt.Printf("%d, %d, %v\n", i, v, si)
}
}for...range 可以遍历 channel， 与遍历 map、slice 不同
go
package main
import "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配合标签跳出指定标签代码块的循环。
go
package main
import "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")
}