Go语言条件语句

条件语句是程序流程控制的一个重要部分。条件语句根据条件表达式的成立与否选择执行分支，从而实现对程序流程的控制。if语句、if-else语句、if-else-if以及嵌套的if语句和switch语句都是条件语句。Go语言特别新增了select语句专用于基于通道的通信操作。

Go语言的条件语句在概念和流程上与其他编程语言完全相同，因此这里不再赘述，写法上结合了Python和C++，即条件表达式不需要加括号，但仍然保留了花括号。具体例子见下：

if系列

if 语句

语法：

if 布尔表达式 {
	// 表达式值为true时执行语句体
}

实例：

package main

import "fmt"

func judge(grade int) {
	if grade >= 60 {
		fmt.Println("Pass")
	}
}

func main() {
	judge(70) // Pass
	judge(55) // (输出空行)
}

if-else语句

语法：

if 布尔表达式 {
	// 表达式值为true时执行语句体
} else {
	// 表达式值为false时执行语句体
}

实例：

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语句也是可以嵌套的，语法也类似。

语法：

if 布尔表达式1 {
	// 布尔表示式1值为true时执行语句体
	if 布尔表达式2 {
		// 布尔表达式2值为true时执行语句体
		if 布尔表达式3 {
			// 布尔表达式3值为true时执行语句体
			....
		}
	} else {
		// 布尔表达式2值为false时执行语句体
		...
	}
} else {
	// 布尔表达式1值为false时执行语句体
}

嵌套是可以无限进行下去的，但嵌套的层数越多，程序的可读性越差，因此不太推荐特别深层的嵌套。

请别小看条件语句，纯靠if-else语句做条件判断就能实现一个简单的FAQ系统。

实例：

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 (判断语句内的数值从大到小)：

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 (判断语句内的数值从小到大)：

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：

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

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中实际存储的变量类型，语法如下：

语法：

switch x.(type) {
	case type1:
		...
	case type2:
		...
	...
	default:
		...
}

实例：

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语句(可选)总是可以运行的。

语法

select {
	case communication_clause1:
		statement(s)
	case communication_clause2:
		statement(s)
	...
	[default]:
		[statement(s)]
}

• 每一个case必须是一个通信语句
• 所有通道表达式都会被求值
• 所有被发送的表达式都会被求值
• 如果任意某个case通信可以进行，它就执行，其他被忽略
• 如果有多个case都可以运行，select会随机公平地选出一个执行，其他case则不会被执行。
• 在没有任何case可以运行的情况下；如果存在default语句，则执行该语句；如果没有default语句，则阻塞，直到某个case可以通信，Go不会重新对通道进行求值。

实例：

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一定不能执行(通道为空，不能发送) default不会执行

Channel是Go的一个重要特性，博主稍后会专门写相关的博客进行介绍。