流程控制是改变程序运行顺序的指令，可能是运行不同位置的指令，或是在二段（或多段）程序中选择一个运行。程序设计语言的流程控制语句，用于设定计算执行的次序，建立程序的逻辑结构。可以说， 流程控制语句是整个程序的骨架。
条件语句
条件判断是依指定变量或表达式的结果，决定后续运行的程序，可以根据指定条件是否成立，决定后续的程序。
对于 Go条件语句，提供了两种方式：
- 单一条件判断：if-else，也可以组合多个if-else指令，进行较复杂的条件判断。
- 多选一条件判断：switch-case。
if else
Go的if语句由一个布尔表达式后紧跟一个或多个语句组成。if 语句后可以使用可选的 else 语句, else 语句中的表达式在布尔表达式为 false 时执行。
通常格式为：
if 布尔表达式 {
/* 在布尔表达式为 true 时执行 */
} else {
/* 在布尔表达式为 false 时执行 */
}其中，Go 的 if 语句表达式外无需小括号 ( ) ，而大括号 { } 则是必须的。同时 {必须紧跟在if语句，不可换行，否则编译或报错–missing condition in if statement。
如下代码：
package main
import "fmt"
func main() {
/* 定义局部变量 */
a := 10
/* 使用 if 语句判断布尔表达式 */
if a < 20 {
/* 如果条件为 true 则执行以下语句 */
fmt.Printf("a 小于 20\n")
} else {
/* 如果条件为 false 则执行以下语句 */
fmt.Printf("a 不小于 20\n")
}
fmt.Printf("a 的值为 : %d\n", a)
}
除此之外，Go的 if 或 else if 语句可以嵌入一个或多个 if 或 else if 语句。
package main
import "fmt"
func main() {
/* 定义局部变量 */
var a int = 100
var b int = 200
/* 判断条件 */
if a == 50 {
fmt.Printf("a 值为: %d\n", a)
} else if a == 100 {
/* if 条件语句为 true 执行 */
if b == 200 {
/* if 条件语句为 true 执行 */
fmt.Printf("a 的值为 100 ， b 的值为 200\n")
}
}
fmt.Printf("a 值为 : %d\n", a)
fmt.Printf("b 值为 : %d\n", b)
}
if 的简短语句
if 语句可以在条件表达式前执行一个简单的语句。
package main
import (
"fmt"
"math"
)
func pow(x, n, lim float64) {
if v := math.Pow(x, n); v < lim {
fmt.Printf("1.math.Pow(%f, %f):%f \n", x, n, v)
} else {
fmt.Printf("2.math.Pow(%f, %f):%f \n", x, n, v)
}
fmt.Println(lim)
}
func main() {
pow(3, 2, 10)
pow(3, 3, 20)
}
这里在if判断表达式之前定义了一个变量v并初始化赋值。需要说明的是该语句声明的变量作用域仅在 if 之内。
switch case
Go的switch和其他语言功能基本一致，都是用于基于不同条件执行不同动作，每一个 case 分支都是唯一的，从上直下逐一测试，直到匹配为止。
具体语法也有Go的特色：
- 首先匹配项后面也不需要再加break
- switch后面的表达式不是必须的
- case 里可以写表达式
- 单个case中，可以出现多个结果选项
- 左花括号{必须与switch处于同一行。这点在Go里很普遍
有一个特殊关键字fallthrough，当且仅当在case中明确添加fallthrough关键字，才会继续执行紧跟的下一个case
一般情况，Go 编程语言中 switch 语句的语法如下：
switch var1 {
case val1:
...
case val2:
...
default:
...
}变量 var1 可以是任何类型，而 val1 和 val2 则可以是同类型的任意值。类型不被局限于常量或整数，但必须是相同的类型；或者最终结果为相同类型的表达式。
package main
import "fmt"
func main() {
/* 定义局部变量 */
var grade string = "B"
var marks int = 90
switch marks {
case 90:
grade = "A"
case 80:
grade = "B"
case 50, 60, 70:
grade = "C"
default:
grade = "D"
}
switch {
case grade == "A":
fmt.Printf("优秀!\n")
case grade == "B", grade == "C":
fmt.Printf("良好\n")
case grade == "D":
fmt.Printf("及格\n")
case grade == "F":
fmt.Printf("不及格\n")
default:
fmt.Printf("差\n")
}
fmt.Printf("你的等级是 %s\n", grade)
}
上面第一个switch中，和其他常见语言中的语法上switch基本一致。在第二个中就比较具有Go的特色。switch后面没有表达式，case语句也可以使用表达式来判断
package main
import "fmt"
func main() {
/* 定义局部变量 */
var grade string = "B"
switch {
case grade == "A":
fmt.Printf("优秀!\n")
fallthrough
case grade == "B", grade == "C":
fmt.Printf("良好\n")
fallthrough
case grade == "D":
fmt.Printf("及格\n")
case grade == "F":
fmt.Printf("不及格\n")
fallthrough
default:
fmt.Printf("差\n")
}
fmt.Printf("你的等级是 %s\n", grade)
}
可以看出，语句成立后，如果加了fallthrough，下一条case就会被执行。
循环语句
Go语言中的循环语句只支持for关键字，不支持while和do-while 结构，可是有些写法却可是实现类似功能。关键字for的基本使用方法与C和C++中非常接近。
基本的 for 循环由三部分组成，它们用分号隔开：
- 初始化语句：在第一次迭代前执行
- 条件表达式：在每次迭代前求值
- 后置语句：在每次迭代的结尾执行
基本形式
Go语言的for循环有3中形式
1、for init; condition; post { }注意条件语句也是不需要（）的。
package main
import "fmt"
func main() {
sum := 0
for i := 0; i <= 100; i++ {
sum += i
}
fmt.Println(sum)
}
上面代码实现了1加到100的运算。
2、for condition { }这个实现的有些像 while ，只要条件成立就一直执行。
package main
import "fmt"
func main() {
var b int = 15
var a int = 10
for a < b {
a++
fmt.Printf("a 的值为: %d\n", a)
}
}
3、for { }这样定义，实际上就是无限循环了。如果省略循环条件，该循环就不会结束。
对于for的条件，还可以使用range 格式可以对 slice、map、数组、字符串等进行迭代循环。
for的range
for key, value := range oldMap {
newMap[key] = value
}package main
import "fmt"
func main() {
numbers := [6]int{1, 2, 3, 5}
for i, x := range numbers {
fmt.Printf("第 %d 位 x 的值 = %d\n", i, x)
}
}
循环控制语句
GO 语言支持以下几种循环控制语句：
- break 语句 经常用于中断当前 for 循环或跳出 switch 语句
package main
import "fmt"
func main() {
/* 定义局部变量 */
var a int = 10
/* for 循环 */
for a < 20 {
fmt.Printf("a 的值为 : %d\n", a)
a++
if a > 15 {
/* 使用 break 语句跳出循环 */
break
}
}
}
- continue 语句 跳过当前循环的剩余语句，然后继续进行下一轮循环。
package main
import "fmt"
func main() {
/* 定义局部变量 */
var a int = 10
/* for 循环 */
for a < 20 {
if a == 15 {
/* 跳过此次循环 */
a = a + 1
continue
}
fmt.Printf("a 的值为 : %d\n", a)
a++
}
}
可以看到，15没有被打出来。
- goto 语句 将控制转移到被标记的语句。也称成为跳转语句。
但是，在结构化程序设计中一般不主张使用goto语句， 以免造成程序流程的混乱，使理解和调试程序都产生困难。
package main
import "fmt"
func main() {
/* 定义局部变量 */
var a int = 10
/* 循环 */
LOOP:
for a < 20 {
if a == 15 {
/* 跳过迭代 */
a = a + 1
goto LOOP
}
fmt.Printf("a的值为 : %d\n", a)
a++
}
}
有疑问加站长微信联系（非本文作者）
