条件语句是程序流程控制的一个重要部分。条件语句根据条件表达式的成立与否选择执行分支，从而实现对程序流程的控制。if语句、if-else语句、if-else-if以及嵌套的if语句和switch语句都是条件语句。Go语言特别新增了select语句专用于基于通道的通信操作。
Go语言的条件语句在概念和流程上与其他编程语言完全相同，因此这里不再赘述，写法上结合了Python和C ，即条件表达式不需要加括号，但仍然保留了花括号。具体例子见下：
if系列
if 语句
语法：
代码语言：javascript复制if 布尔表达式 {
// 表达式值为true时执行语句体
}实例：
代码语言：javascript复制package main
import "fmt"
func judge(grade int) {
if grade >= 60 {
fmt.Println("Pass")
}
}
func main() {
judge(70) // Pass
judge(55) // (输出空行)
}if-else语句
语法：
代码语言：javascript复制if 布尔表达式 {
// 表达式值为true时执行语句体
} else {
// 表达式值为false时执行语句体
}实例：
代码语言：javascript复制package main
import "fmt"
func judge(grade int) {
if grade >= 60 {
fmt.Println("Pass")
} else {
fmt.Println("Fail")
}
}
func main() {
judge(70) // Pass
judge(55) // Fail
}嵌套if语句
同其他语言，Go的if语句、if-else语句也是可以嵌套的，语法也类似。
语法：
代码语言：javascript复制if 布尔表达式1 {
// 布尔表示式1值为true时执行语句体
if 布尔表达式2 {
// 布尔表达式2值为true时执行语句体
if 布尔表达式3 {
// 布尔表达式3值为true时执行语句体
....
}
} else {
// 布尔表达式2值为false时执行语句体
...
}
} else {
// 布尔表达式1值为false时执行语句体
}嵌套是可以无限进行下去的，但嵌套的层数越多，程序的可读性越差，因此不太推荐特别深层的嵌套。
请别小看条件语句，纯靠if-else语句做条件判断就能实现一个简单的FAQ系统。
实例：
代码语言：javascript复制package main
func judge(grade int, gender string) {
if grade > 60 {
if gender == "女生" {
println("合格的女生")
} else if gender == "男生" {
println("合格的男生")
} else {
println("性别未知")
}
} else {
if gender == "女生" {
println("不合格的女生")
} else if gender == "男生" {
println("不合格的男生")
} else {
println("性别未知")
}
}
}
func main() {
judge(70, "男生") // 合格的男生
judge(55, "女生") // 不合格的女生
judge(100, "秀吉") // 性别未知
}switch语句
switch语句基于判断条件的多种状况选择不同的执行路径，使用case来进行分支判断，每一个case语句内部包含了条件满足时要执行的代码。执行时，会从上到下判断所有的case分支，直到匹配或者所有分支都判断完毕。如果没有匹配但有default语句，默认执行default语句内的动作。
在其他编程语言里每一个case语句里面可以使用break语句来终止判断流程，执行switch语句之后的代码。但Go语言如果某一个case已经满足，则默认流程结束，不会判断后面的case语句。这相当于Go语言的case语句里全部默认以break结尾。
Go语言在其他语言的基础上引入了fallthrough语句，程序执行到fallthrough之后将会强制执行后面的一条case语句，无论判断条件是否成立。这可以扩充switch语句的功能，使得流程控制更加灵活，在一些极端例子下非常好用。
语法 ([]表示可选项)：
switch [var] {
case var1:
...
case var2:
[fallthrough]
case var3:
...
[default]:
[...]
}实例1 (判断语句内的数值从大到小)：
代码语言：javascript复制package main
import "fmt"
func main() {
grade := 80
switch {
case grade >= 90:
fmt.Println("顶尖")
case grade >= 80:
fmt.Println("优秀")
case grade >= 70:
fmt.Println("良好")
case grade >= 60:
fmt.Println("及格")
case grade < 60:
fmt.Println("未通过")
}
}
// 优秀实例2 (判断语句内的数值从小到大)：
代码语言：javascript复制package main
import "fmt"
func main() {
grade := 80
switch {
case grade < 60:
fmt.Println("未通过")
case grade >= 60:
fmt.Println("及格")
case grade >= 70:
fmt.Println("良好")
case grade >= 80:
fmt.Println("优秀")
case grade >= 90:
fmt.Println("顶尖")
}
}
// 及格实例3：
代码语言：javascript复制package main
import "fmt"
func sex_judge(gender int) {
switch gender {
case 0:
fmt.Println("男性")
case 1:
fmt.Println("女性")
case 2:
fmt.Println("秀吉")
default:
fmt.Println("该系统不够民主，不支持其他性别")
}
}
func main() {
gender := 0 // 0：男性 1：女行 2：秀吉 3：生理性别男心理性别女 4：生理性别女心理性别男 5：男性转女性 6：女性转男性
sex_judge(gender) // 男性
gender = 3
sex_judge(gender) // 该系统不够民主，不支持其他性别
}实例4
代码语言：javascript复制package main
import "fmt"
func sex_judge(gender int) {
switch gender {
case 0:
fmt.Println("男性")
case 1:
fmt.Println("女性")
case 2:
fmt.Println("秀吉")
fallthrough
case 3:
fmt.Println("生理性别男心理性别女")
case 4:
fmt.Println("生理性别女心理性别男")
case 5:
fmt.Println("男性转女性")
case 6:
fmt.Println("女性转男性")
default:
fmt.Println("该系统不暂时支持其他性别")
}
}
func main() {
gender := 0 // 0：男性 1：女行 2：秀吉 3：生理性别男心理性别女 4：生理性别女心理性别男 5：男性转女性 6：女性转男性
sex_judge(gender)
// 男性
gender = 2
sex_judge(gender)
// 秀吉
// 生理性别男心理性别女
}switch语句的作用
当然，你可以使用多个if语句来实现和switch语句一样的功能，但使用switch语句的优点在于实现起来更加简单，程序流程更加清晰，代码可读性更高。
Type Switch (先做了解)
Go语言中的switch可以被用于type-switch来判断interface中实际存储的变量类型，语法如下：
语法：
代码语言：javascript复制switch x.(type) {
case type1:
...
case type2:
...
...
default:
...
}实例：
代码语言：javascript复制package main
import (
"fmt"
)
func main() {
var t interface{}
switch t.(type) {
case nil:
fmt.Println("nil")
case int:
fmt.Println("int")
case bool:
fmt.Println("bool")
case string:
fmt.Println("string")
default:
fmt.Println("unkonw type")
}
}select语句 (先做了解)
select语句是Go语言新增一个流程控制语句，你可以理解它为专用于通信的switch语句。select语句里的cae必须是一个基于通道的通信操作(发送或者接收)。
select语句将随机执行一个可以通信的case，如果所有case都不能运行，它将被阻塞，直到有case可运行。default语句(可选)总是可以运行的。
语法
代码语言：javascript复制select {
case communication_clause1:
statement(s)
case communication_clause2:
statement(s)
...
[default]:
[statement(s)]
}- 每一个case必须是一个通信语句
- 所有通道表达式都会被求值
- 所有被发送的表达式都会被求值
- 如果任意某个case通信可以进行，它就执行，其他被忽略
- 如果有多个case都可以运行，select会随机公平地选出一个执行，其他case则不会被执行。
- 在没有任何case可以运行的情况下；如果存在default语句，则执行该语句；如果没有default语句，则阻塞，知道某个case可以通信，Go不会重新对通道进行求值。
实例：
代码语言：javascript复制package main
import (
"fmt"
)
func main() {
var c1, c2 chan int
var a = 1
c1 = make(chan int, 10)
c2 = make(chan int, 10)
select {
case c1 <- a:
fmt.Println("Send", a, "to c1")
case c2 <- a:
fmt.Println("Send", a, "to c2")
case b := <- c1:
fmt.Println("Received", b, "from c1")
case b := <- c2:
fmt.Println("Received", b, "from c2")
default:
fmt.Println("No communication")
}
}
// 程序执行的结果有以下两种：
// Send 1 to c1
// Send 2 to c2
// 以上两种随机出现
// 不会有其他种类 因为前两个case一定可以执行 后两个case一定不能执行(通道为空，不能发送) defaul不会执行Channel是Go的一个重要特性，博主稍后会专门写相关的博客进行介绍。
