1. 条件语句
1.1 if 语句
if 语句是一种常用的条件语句，用于根据某个条件执行特定的代码块。在 Golang 中，if 语句的语法如下：
|
1
2
3
4
5
6
7
|
if condition { // 执行代码块 } else if condition2 { // 执行代码块2 } else { // 执行代码块3 } |
其中，condition 是需要被判断的条件，如果它的值为 true，则执行if语句后面的代码块；如果 condition 的值为 false，则执行 else 语句后面的代码块。如果if语句后面有 else if 语句，则会依次判断每个 else if 语句的条件，如果条件为 true，则执行相应的代码块，否则继续判断下一个 else if 语句的条件。如果所有的 else if 语句都不满足条件，则执行 else 语句后面的代码块。
下面是一个简单的if语句示例：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
package main import "fmt" func main() { age := 20 if age >= 18 { fmt.Println("成年人") } else { fmt.Println("未成年人") } } |
输出结果为：
成年人
1.2 switch 语句
switch 语句也是一种常用的条件语句，用于根据变量的值在多个不同的分支中选择执行的代码块。在 Golang 中，switch 语句的语法如下：
|
1
2
3
4
5
6
7
8
|
switch variable { case value1: // 执行代码块1 case value2: // 执行代码块2 default: // 执行默认代码块 } |
其中，variable 是需要被判断的变量，case 是值匹配的条件，如果 variable 的值与 case 中的值相等，则执行相应的代码块；如果没有一个 case 匹配 variable 的值，则执行 default 语句后面的代码块。
下面是一个简单的 switch 语句示例：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
package main import "fmt" func main() { fruit := "apple" switch fruit { case "banana": fmt.Println("这是香蕉") case "apple": fmt.Println("这是苹果") default: fmt.Println("这是其他水果") } } |
输出结果为：
这是苹果
2. 循环语句
2.1 for 语句
for 语句是一种常用的循环语句，用于重复执行某个代码块，也可以用于迭代数组、切片和映射等数据结构中的元素。在 Golang 中，for 语句的语法如下：
|
1
2
3
|
for initialization; condition; increment { // 执行代码块 } |
其中，initialization 是初始化语句，可以用来初始化循环计数器；condition 是循环条件，如果 condition 的值为 true，则执行 for 语句后面的代码块；increment 是循环计数器的更新语句，每次循环执行完后，都会执行 increment 语句来更新循环计数器的值。
下面是一个简单的 for 语句示例，用来计算 1 到 10 的和：
|
1
2
3
4
5
6
7
8
9
10
11
|
package main import "fmt" func main() { sum := 0 for i := 1; i <= 10; i++ { sum += i } fmt.Println("1到10的和为：", sum) } |
输出结果为：
1到10的和为： 55
2.2 range 语句
range 语句用于迭代数组、切片、映射等数据结构中的元素。在 Golang 中，range 语句的语法如下：
|
1
2
3
|
for index, value := range array/slice/map { // 执行代码块} |
其中，index 是元素的下标或键，value 是元素的值。在迭代数组或切片时，index 表示元素的下标；在迭代映射时，index 表示元素的键。下面是一个简单的 range 语句示例，用来迭代数组：
|
1
2
3
4
5
6
7
8
9
10
|
package mainimport "fmt"func main() { numbers := [5]int{1, 2, 3, 4, 5} for i, num := range numbers { fmt.Println("下标为", i, "的元素是：", num) }} |
输出结果为：
下标为 0 的元素是： 1
下标为 1 的元素是： 2
下标为 2 的元素是： 3
下标为 3 的元素是： 4
下标为 4 的元素是： 5
3. 跳转语句
3.1 break 语句
break 语句用于跳出当前的循环语句。在 Golang 中，break 语句的语法如下：
|
1
2
3
4
5
6
|
for initialization; condition; increment { // 执行代码块 if condition2 { break }} |
其中，如果 condition2 的值为 true，则执行 break 语句，跳出循环。
下面是一个简单的 break 语句示例，用来找出数组中的第一个负数：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
package mainimport "fmt"func main() { numbers := [5]int{1, 2, -3, 4, 5} for _, num := range numbers { if num < 0 { fmt.Println("找到第一个负数：", num) break } }} |
输出结果为：
找到第一个负数： -3
3.2 continue 语句
continue 语句用于跳过当前循环中的某次迭代，直接进入下一次迭代。在 Golang 中，continue 语句的语法如下：
|
1
2
3
4
5
6
|
for initialization; condition; increment { // 执行代码块 if condition2 { continue }} |
其中，如果 condition2 的值为 true，则执行 continue 语句，跳过当前迭代，直接进入下一次迭代。
下面是一个简单的 continue 语句示例，用来打印 1 到 10 之间的奇数：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
package mainimport "fmt"func main() { for i := 1; i <= 10; i++ { if i%2 == 0 { continue } fmt.Println(i) }} |
输出结果为：
1
3
5
7
9
3.3 goto 语句
goto 语句用于无条件跳转到指定的标签处。在 Golang 中，goto 语句的语法如下：
|
1
2
3
4
|
goto label...label:// 执行代码块 |
其中，label 是一个标识符，用来标记某个代码块。当执行到 goto 语句时，会跳转到指定的标签处，继续执行后面的代码块。
下面是一个简单的 goto 语句示例，用来模拟一个死循环：
|
1
2
3
4
5
6
7
8
|
package mainfunc main() {Loop: for { goto Loop }} |
在上面的示例中，程序会一直执行 for 循环，而不会停止。
4. 错误处理语句
在 Golang 中，错误处理是一项非常重要的任务，因为它可以帮助程序更好地处理错误，从而提高程序的可靠性和稳定性。
4.1 defer 语句
defer 语句用于在函数退出前执行某些操作，比如关闭文件、释放资源等。在 Golang 中，defer 语句的语法如下：
|
1
|
defer func_name(args) |
其中，func_name 是需要执行的函数名，args 是函数的参数列表。当函数退出时，会依次执行所有的defer语句。
下面是一个简单的 defer 语句示例，用来演示 defer 语句的执行顺序：
|
1
2
3
4
5
6
7
8
9
10
|
package mainimport "fmt"func main() { defer fmt.Println("defer 1") defer fmt.Println("defer 2") defer fmt.Println("defer 3") fmt.Println("Hello, world!")} |
输出结果为：
|
1
2
3
4
|
Hello, world!defer 3defer 2defer 1 |
在上面的示例中，先执行 fmt.Println("Hello, world!") 语句，再依次执行所有的 defer 语句。
4.2 panic 语句
panic 语句用于引发一个运行时错误，并使程序崩溃。在 Golang 中，panic 语句的语法如下：
|
1
|
panic("error message") |
其中，"error message" 是一个字符串，用于描述错误信息。当程序执行到 panic 语句时，会引发一个 panic 错误，并将程序崩溃。
4.3 recover 语句
recover 语句用于恢复程序的执行，如果程序发生了 panic 错误，可以使用 recover 语句来捕获该错误，并进行相应的处理。在 Golang 中，recover 语句的语法如下：
recover 语句用于恢复程序的执行，如果程序发生了 panic 错误，可以使用 recover 语句来捕获该错误，并进行相应的处理。在 Golang 中，recover 语句的语法如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
package mainimport "fmt"func main() { defer func() { if err := recover(); err != nil { fmt.Println("recover error:", err) } }() panic("panic error")} |
输出结果为：
|
1
|
recover error: panic error |
在上面的示例中，使用 defer 语句来定义一个匿名函数，用来捕获 panic 错误，并输出错误信息。
5. 总结
流程控制语句是程序设计中非常重要的一部分，它们可以帮助我们控制程序的执行流程，实现复杂的逻辑功能。在 Golang 中，流程控制语句包括分支控制语句和循环控制语句两种类型，分别用于控制程序的分支和循环。
在学习流程控制语句时，我们需要了解每种语句的语法和用法，以及它们之间的区别和联系。同时，我们也需要注意一些注意事项，例如在使用 if 语句时，需要注意多个条件的优先级关系；在使用 switch 语句时，需要注意 case 语句的 break 关键字；在使用循环控制语句时，需要注意循环的执行顺序和终止条件。
最后，需要强调的是，流程控制语句虽然非常有用，但在实际编程中，我们也需要注意代码的可读性和可维护性，尽量避免过多的嵌套和复杂的控制流程，使代码更加简洁和易于理解。
以上就是深入学习Golang的流程控制的详细内容，更多关于Golang 流程控制的资料请关注服务器之家其它相关文章！
原文链接：https://juejin.cn/post/7227760934001229882
