流程控制是每种编程语言控制逻辑走向和执行次序的重要部分，流程控制可以说是一门语言的“经脉”。

Go 语言中最常用的流程控制有 if 和 for，而 switch 和 goto 主要是为了简化代码、降低重复代码而生的结构，属于扩展类的流程控制。

if else（分支结构）

1. if 条件判断基本写法

Go 语言中 if 条件判断的格式如下：

if 表达式 1 {
分支 1
} else if 表达式 2 {
分支 2
} else{
分支 3
}

当表达式 1 的结果为 true 时，执行分支 1，否则判断表达式 2，如果满足则执行分支 2，都不满足时，则执行分支 3。 if 判断中的 else if 和 else 都是可选的，可以根据实际需要进行选择。

注意：Go 语言规定与 if 匹配的左括号{必须与 if 和表达式放在同一行，{放在其他位置会触发编译错误。 同理，与 else 匹配的{也必须与 else 写在同一行，else 也必须与上一个 if 或else if 右边的大括号在同一行。

代码示例：

package mainimport "fmt"func ifDemo(score int) {if score >= 90 {fmt.Println("A")} else if score > 75 {fmt.Println("B")} else {fmt.Println("C")}
}
func main() {ifDemo(65)
}

2. if 条件判断特殊写法

if 条件判断还有一种特殊的写法，可以在 if 表达式之前添加一个执行语句，再根据变量值进行判断，

代码示例：

package mainimport "fmt"func ifDemo(score int) {if score := score; score >= 90 {fmt.Println("A")} else if score > 75 {fmt.Println("B")} else {fmt.Println("C")}}
func main() {ifDemo(65)
}

这种写法和上面的区别就是下面的score是局部作用域，除非有特别的需求需要在条件内部重新定义变量，否则这种写法个人并不推荐。

for（循环结构）

Go 语言中的所有循环类型均可以使用 for 关键字来完成。
for 循环的基本格式如下：

for 初始语句;条件表达式;结束语句{
循环体语句
}

条件表达式返回 true 时循环体不停地进行循环，直到条件表达式返回 false 时自动退出循环。

代码示例：

package mainimport "fmt"func main() {for i := 0; i < 10; i++ {fmt.Println(i)}
}

for 循环的初始语句可以被忽略，但是初始语句后的分号必须要写，例如：

package mainimport "fmt"func main() {i := 0for ; i < 10; i++ {fmt.Println(i)}
}

for 循环的初始语句和结束语句都可以省略，例如：

package mainimport "fmt"func main() {i := 0for i < 10 {fmt.Println(i)i++}
}

这种写法类似于其他编程语言中的 while，在 while 后添加一个条件表达式，满足条件表达式时持续循环，否则结束循环。

注意：Go 语言中是没有 while 语句的，我们可以通过 for 代

for 无限循环结构：

for {
循环体语句
}

for 循环可以通过 break、goto、return、panic 语句强制退出循环。

代码示例：

package mainimport "fmt"func main() {k := 1for { // 这里也等价 for ; ; {if k <= 10 {fmt.Println("ok~~", k)} else {break //break 就是跳出这个 for 循环}k++}
}

for range（键值循环）

Go 语言中可以使用 for range 遍历数组、切片、字符串、map 及通道（channel）。 通过 for
range 遍历的返回值有以下规律：

• 数组、切片、字符串返回索引和值
• map 返回键和值
• 通道（channel）只返回通道内的值

代码示例：

package mainimport "fmt"func main() {str := "abc 上海"for index, val := range str {fmt.Printf("index=%d, val=%c \n", index, val)}for _, val := range str {fmt.Printf("val=%c \n", val)}}

结果：

index=0, val=a 
index=1, val=b 
index=2, val=c 
index=3, val=  
index=4, val=上 
index=7, val=海 
val=a 
val=b 
val=c 
val=  
val=上 
val=海 

switch case

使用 switch 语句可方便地对大量的值进行条件判断，Go 语言规定每个 switch 只能有一个 default 分支。

代码示例：

package mainimport "fmt"func main() {extname := ".a"switch extname {case ".html":fmt.Println("text/html")breakcase ".css":fmt.Println("text/css")breakcase ".js":fmt.Println("text/javascript")breakdefault:fmt.Println("格式错误")break}
}

结果：

格式错误

Go 语言中每个 case 语句中可以不写 break，不加 break 也不会出现穿透的现象 如下例子：

package mainimport "fmt"func main() {extname := ".a"switch extname {case ".html":fmt.Println("text/html")case ".css":fmt.Println("text/css")case ".js":fmt.Println("text/javascript")default:fmt.Println("格式错误")}
}

结果仍然是：

格式错误

在Go语言中，break关键字在switch语句中的使用确实与C、C++或Java等传统编程语言有所不同。由于Go的switch语句默认情况下会在匹配并执行一个case后自动终止（即自动阻止“fall through”行为），因此大多数情况下你不需要也不应该使用break。
然而，这并不意味着break关键字在Go的switch语句中完全没有价值。实际上，break仍然可以在特定情境下使用，主要用于提前退出整个switch结构。例如，如果你在一个case中有复杂的逻辑判断，并且在某些条件下希望提前结束switch语句，可以使用break来实现这一点

一个分支可以有多个值，多个 case 值中间使用英文逗号分隔:

package mainimport "fmt"func main() {n := 2switch n {case 1, 3, 5, 7, 9:fmt.Println("奇数")case 2, 4, 6, 8:fmt.Println("偶数")default:fmt.Println(n)}
}

结果：

偶数

switch 的穿透 fallthrough

fallthrough`语法可以执行满足条件的 case 的下一个 case，是为了兼容 C 语言中的 case 设计的。

package mainimport "fmt"func switchDemo(s string) {switch {case s == "a":fmt.Println("a")fallthroughcase s == "b":fmt.Println("b")case s == "c":fmt.Println("c")default:fmt.Println("...")}
}
func main() {switchDemo("a")
}

结果：

a
b

break（跳出循环）

Go 语言中 break 语句用于以下几个方面：

• 用于循环语句中跳出循环，并开始执行循环之后的语句
• break 在 switch（开关语句）中在执行一条 case后跳出语句的作用
• 在多重循环中，可以用标号 label 标出想 break 的循环

1. switch（开关语句）中在执行一条 case 后跳出语句的作用

package mainimport "fmt"func main() {extname := ".html"switch extname {case ".html":fmt.Println("text/html")breakcase ".css":fmt.Println("text/css")breakcase ".js":fmt.Println("text/javascript")breakdefault:fmt.Println("格式错误")}
}

使用break可以在满足条件后就推出程序，不再继续执行后面的case了。

2. for 循环中默认 break 只能跳出一层循环

代码示例：

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

结果：

i j 的值 0 - 0
i j 的值 0 - 1
i j 的值 1 - 0
i j 的值 1 - 1

3. 在多重循环中，可以用标号 label 标出想 break 的循环

代码示例：

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

结果：

i j 的值 0 - 0
i j 的值 0 - 1

continue（继续下一次循环）

continue 语句可以结束当前循环，开始下一次的循环迭代过程，仅限在 for 循环内使用。

代码示例：

package mainimport "fmt"func main() {for i := 0; i < 2; i++ {for j := 0; j < 4; j++ {if j == 2 {continue}fmt.Println("i j 的值", i, "-", j)}}
}

结果：

i j 的值 0 - 0
i j 的值 0 - 1
i j 的值 0 - 3
i j 的值 1 - 0
i j 的值 1 - 1
i j 的值 1 - 3

在 continue 语句后添加标签时，表示开始标签对应的循环。例如：

package mainimport "fmt"func main() {
here:for i := 0; i < 2; i++ {for j := 0; j < 4; j++ {if j == 2 {continue here}fmt.Println("i j 的值", i, "-", j)}}
}

结果：

i j 的值 0 - 0
i j 的值 0 - 1
i j 的值 1 - 0
i j 的值 1 - 1

goto（跳转到指定标签）

goto 语句通过标签进行代码间的无条件跳转。goto 语句可以在快速跳出循环、避免重复退出上有一定的帮助。Go 语言中使用 goto 语句能简化一些代码的实现过程。

示例代码：

package mainimport "fmt"func main() {var n int = 30fmt.Println("ok1")if n > 20 {goto label1}fmt.Println("ok2")fmt.Println("ok3")fmt.Println("ok4")
label1:fmt.Println("ok5")fmt.Println("ok6")fmt.Println("ok7")
}

结果：

ok1
ok5
ok6
ok7

使用 goto 语句能简化代码:

package mainimport "fmt"func main() {for i := 0; i < 10; i++ {for j := 0; j < 10; j++ {if j == 2 {// 设置退出标签goto breakTag}fmt.Printf("%v-%v\n", i, j)}}return// 标签
breakTag:fmt.Println("结束 for 循环")
}

结果：

0-0
0-1
结束 for 循环

参考文献

https://go.dev/doc/tutorial/getting-started

https://gobyexample.com/

https://www.w3schools.com/go/

https://go.dev/doc/tutorial/

https://www.geeksforgeeks.org/golang-tutorial-learn-go-programming-language/