Go 语言条件语句
在 Go 语言中,条件语句用于根据给定条件执行不同的代码块。条件语句需要指定一个或多个条件,并通过测试条件是否为 true 来决定是否执行指定代码块,并在条件为 false 的情况再执行另外的代码块。本节将介绍 Go 语言的几种条件语句,包括 if-else
语句、switch
语句、type-switch
语句,以及用于通信的 select
语句。
本文所有示例代码可在 GitHub 下载。
if 语句
if
语句由布尔表达式后紧跟一个或多个语句组成。Go 语言中 if
语句的语法如下:
if condition {
// 如果条件为真,执行这里的代码
}
if
在布尔表达式为 true 时,其后紧跟的语句块执行,如果为 false 则不执行。
请看下面实例:
package main
import "fmt"
func main() {
/* 定义局部变量 */
var a int = 10
/* 使用 if 语句判断布尔表达式 */
if a < 20 {
/* 如果条件为 true 则执行以下语句 */
fmt.Printf("a 小于 20\n")
}
fmt.Printf("a 的值为 %d\n", a)
}
以上代码执行结果为:
a 小于 20
a 的值为 10
if-else 语句
if
语句后可以使用可选的 else
语句,else
语句中的表达式在布尔表达式为 false 时执行。Go 语言中 if...else
语句的语法如下:
if condition {
// 如果条件为真,执行这里的代码
} else {
// 如果条件为假,执行这里的代码
}
if
在布尔表达式为 true 时,其后紧跟的语句块执行,如果为 false 则执行 else
语句块。
请看下面实例:
package main
import "fmt"
func main() {
/* 局部变量定义 */
var a int = 100
/* 判断布尔表达式 */
if a < 20 {
/* 如果条件为 true 则执行以下语句 */
fmt.Printf("a 小于 20\n")
} else {
/* 如果条件为 false 则执行以下语句 */
fmt.Printf("a 不小于 20\n")
}
fmt.Printf("a 的值为 %d\n", a)
}
以上代码执行结果为:
a 不小于 20
a 的值为 100
if-else if 语句
if
语句后面除了可以带 else
语句,还可以一个或多个 else if
语句,如果 else if
语句中的布尔表达式为 true 则执行该语句块。Go 语言中 if...else if
语句的语法如下:
if condition1 {
// 如果条件1为真,执行这里的代码
}
else if condition2 {
// 如果条件2为真,执行这里的代码
} else {
// 如果上述条件均为假,执行这里的代码
}
请看下面实例:
package main
import "fmt"
func main() {
/* 局部变量定义 */
var a int = 50
/* 判断布尔表达式 */
if a < 20 {
fmt.Printf("a 小于 20\n")
} else if a < 40 {
fmt.Printf("a 大于等于 20,小于 40\n")
} else if a < 60 {
fmt.Printf("a 大于等于 40,小于 60\n")
} else {
fmt.Printf("a 不小于 60\n")
}
fmt.Printf("a 的值为 %d\n", a)
}
以上代码执行结果为:
a 大于等于 40,小于 60
a 的值为 50
if 嵌套语句
你还可以在 if
或 else if
语句中嵌入一个或多个 if
或 else if
语句。Go 语言中 if...else
语句的语法如下:
if condition1 {
// 如果条件1为真,执行这里的代码
if condition2 {
// 如果条件2为真,执行这里的代码
}
}
你可以以同样的方式在 if
语句中嵌套 else if...else
语句
请看下面实例:
package main
import "fmt"
func main() {
/* 定义局部变量 */
var a int = 100
var b int = 200
/* 判断条件 */
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 )
}
以上代码执行结果为:
a 的值为 100,b 的值为 200
a 值为 100
b 值为 200
switch 语句
switch
语句用于基于不同条件执行不同动作,每一个 case
分支都是唯一的,从上直下逐一测试,直到匹配为止。你可以定义任意个数的 case
分支。
值得注意的是,不同于 C/C++ 等编程语言,Go 语言的 switch
语句匹配项后面不需要添加 break
语句。
Go 语言中 switch
语句的语法如下:
switch expression {
case value1:
// 如果expression的值等于value1,执行这里的代码
case value2:
// 如果expression的值等于value2,执行这里的代码
default:
// 如果以上条件都不满足,执行这里的代码
}
变量 expression
可以是任何类型,而 value1
和 value2
则可以是同类型的任意值。类型不被局限于常量或整数,但必须是相同的类型;或者最终结果为相同类型的表达式。
你可以同时测试多个可能符合条件的值,使用逗号分割它们,例如 case val1, val2, val3
。
请看下面实例:
package main
import "fmt"
func main() {
/* 定义局部变量 */
var grade string = "B"
var score int = 90
switch score {
case 90: grade = "A"
case 80: grade = "B"
case 60, 70: grade = "C"
default: grade = "D"
}
switch {
case grade == "A" :
fmt.Printf("优秀!\n")
case grade == "B" :
fmt.Printf("良好\n")
case grade == "C" :
fmt.Printf("及格\n")
default:
fmt.Printf("不及格\n")
}
fmt.Printf("你的等级是 %s\n", grade)
}
以上代码执 行结果为:
优秀!
你的等级是 A
type-switch 语句
type-switch
语句与普通的 switch
语句类似,但是在 case
后面跟着的不是具体的值,而是类型。用于根据接口值的实际类型执行不同的代码块。
Type Switch 语法格式如下:
switch value.(type){
case type1:
// 如果value的类型是type1,执行这里的代码
case type2:
// 如果value的类型是type2,执行这里的代码
default: /* 可选 */
// 如果以上类型都不匹配,执行这里的代码
}
在type-switch
语句中,value
是一个接口值(interface
变量),(type)
用于获取接口值的实际类型。然后,case
后面跟着的是具体的类型,用于匹配接口值的实际类型。
请看下面实例(这里用到了函数,后面章节将详细介绍):
package main
import "fmt"
func checkType(i interface{}) {
switch i.(type) {
case int:
fmt.Println("i 是一个整数")
case float64:
fmt.Println("i 是一个浮点数")
case string:
fmt.Println("i 是一个字符串")
default:
fmt.Println("i 的类型未知")
}
}
func main() {
checkType(10)
checkType(3.14)
checkType("Hello")
checkType(true)
}
以上代码执行结果为:
i 是一个整数
i 是一个浮点数
i 是一个字符串
i 的类型未知
select 语句
select
语句是 Go 语言特有的设计,语法类似于 switch
语句,但只能用于处理一个或多个通道的发送和接收操作。也就是说,每个 case
必须是一个通信操作,要么是发送要么是接收。由于涉及通信,因此 select
语句会阻塞,直到其中一个 case
可以执行,然后执行该 case
中的代码。
以下是 select
语句的基本语法:
select {
case <-channel1:
// 如果 channel1 可以接收数据,则执行这里的代码
case data := <-channel2:
// 如果 channel2 可以接收数据,则执行这里的代码,并将接收到的数据存储在变量 data 中
case channel3 <- value:
// 如果 channel3 可以发送数据,则执行这里的代码,将 value 发送到 channel3 中
default:
// 如果没有任何 case 可以执行,则执行这里的代码
}
select
语句包含一个或多个 case
分支,每个 case
分支描述了一个通道操作,可以是接收操作、发送操作或者其他操作。当 select
语句执行时,它会尝试执行每个 case
分支,并选择第一个可以操作的分支执行,如果有多个分支可以操作,则会随机选择一个。如果没有任何分支可以操作,则会执行 default
分支(如果有的话),否则 select
语句会阻塞,直到有一个分支可以操作。
请看下面实例:
package main
import (
"fmt"
"time"
)
func main() {
ch1 := make(chan int)
ch2 := make(chan int)
go func() {
time.Sleep(1 * time.Second)
ch1 <- 1
}()
go func() {
time.Sleep(2 * time.Second)
ch2 <- 2
}()
for {
select {
case <-ch1:
fmt.Println("Received from channel 1")
case <-ch2:
fmt.Println("Received from channel 2")
default:
// fmt.Println("no communication")
}
}
}
以上代码执行结果为:
Received from channel 1
Received from channel 2
在上面的示例中,我们创建了两个通道 ch1
和 ch2
,并在两个 goroutine 中分别向它们发送数据。然后,我们使用 select
语句来等待哪个通道首先接收到数据,并打印相应的消息。由于 ch1
通道在 1 秒后接收到数据,而ch2
通道在 2 秒后接收到数据,因此 select
语句会先选择执行 case <-ch1
分支,并打印 "Received from channel 1"。
更多关于 goroutine 和 channel 的更多内容,我们将在 Go 语言并发模型 进行讲解。