8 Go 语言条件语句

条件语句需要开发者通过指定一个或多个条件，并通过测试条件是否为 true 来决定是否执行指定语句，并在条件为 false 的情况在执行另外的语句。

下图展示了程序语言中条件语句的结构：

Go 语言提供了以下几种条件判断语句：

语句	描述
if 语句	if 语句 由一个布尔表达式后紧跟一个或多个语句组成。
if...else 语句	if 语句 后可以使用可选的 else 语句, else 语句中的表达式在布尔表达式为 false 时执行。
if 嵌套语句	你可以在 if 或 else if 语句中嵌入一个或多个 if 或 else if 语句。
switch 语句	switch 语句用于基于不同条件执行不同动作。
select 语句	select 语句类似于 switch 语句，但是select会随机执行一个可运行的case。如果没有case可运行，它将阻塞，直到有case可运行。

7.1 if 语句

        if 语句由布尔表达式后紧跟一个或多个语句组成。

语法

        Go 编程语言中 if 语句的语法如下：

1. if 布尔表达式 {

2. /* 在布尔表达式为 true 时执行 */

3. }

        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

 

7.2 if...else 语句

 

        if 语句 后可以使用可选的 else 语句, else 语句中的表达式在布尔表达式为 false 时执行。

语法

        Go 编程语言中 if...else 语句的语法如下：

if 布尔表达式 {

/* 在布尔表达式为 true 时执行 */

} else {

/* 在布尔表达式为 false 时执行 */

}

        If 在布尔表达式为 true 时，其后紧跟的语句块执行，如果为 false 则执行 else 语句块。

        流程图如下：

实例

package main


import "fmt"


func main() {

/* 局部变量定义 */

var a int = 50;


/* 判断布尔表达式 */

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 的值为 : 50

 

7.3 if 语句嵌套

 

        你可以在 if 或 else if 语句中嵌入一个或多个 if 或 else if 语句。

语法

        Go 编程语言中 if...if 语句的语法如下：

if 布尔表达式 1 {

/* 在布尔表达式 1 为 true 时执行 */

if 布尔表达式 2 {

/* 在布尔表达式 2 为 true 时执行 */

}

}

        你可以以同样的方式在 if 语句中嵌套 else if...else 语句

实例

package main


import "fmt"


func main() {

/* 定义局部变量 */

var a int = 10

var b int = 20


/* 判断条件 */

if a == 10 {

/* if 条件语句为 true 执行 */

if b == 20 {

/* if 条件语句为 true 执行 */

fmt.Printf("a 的值为 10 ， b 的值为 20\n" );

}

}

fmt.Printf("a 值为 : %d\n", a )

fmt.Printf("b 值为 : %d\n", b )

}

        以上代码执行结果为：

a 的值为 10 ， b 的值为 20
a 值为 : 10
b 值为 : 20

 

7.4 switch 语句

 

        switch 语句用于基于不同条件执行不同动作，每一个 case 分支都是唯一的，从上至下逐一测试，直到匹配为止。

        switch 语句执行的过程从上至下，直到找到匹配项，匹配项后面也不需要再加break。

语法

        Go 编程语言中 switch 语句的语法如下：

switch var1 {

case val1:

...

case val2:

...

default:

...

}

        变量 var1 可以是任何类型，而 val1 和 val2 则可以是同类型的任意值。类型不被局限于常量或整数，但必须是相同的类型；或者最终结果为相同类型的表达式。

        您可以同时测试多个可能符合条件的值，使用逗号分割它们，例如：case val1, val2, val3。

流程图：

实例

package main


import "fmt"


func main() {

/* 定义局部变量 */

var grade string

var marks int = 90


switch marks {

case 90:

grade = "A"

case 80:

grade = "B"

case 70:

grade = "C"

case 60:

grade = "D"

default:

grade = "F"

}


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)

}

        以上代码执行结果为：

优秀!
你的等级是 A

Type Switch

        switch 语句还可以被用于 type-switch 来判断某个 interface 变量中实际存储的变量类型。

        Type Switch 语法格式如下：

switch x.(type){

case type:

statement(s)

case type:

statement(s)

/* 你可以定义任意个数的case */

default: /* 可选 */

statement(s)

}

实例

package main


import "fmt"


func main() {

var x interface{}


switch i := x.(type) {

case nil:

fmt.Printf(" x 的类型 :%T", i)

case int:

fmt.Printf("x 是 int 型")

case float64:

fmt.Printf("x 是 float64 型")

case func(int) float64:

fmt.Printf("x 是 func(int) 型")

case bool, string:

fmt.Printf("x 是 bool 或 string 型")

default:

fmt.Printf("未知型")

}

}

        以上代码执行结果为：

x 的类型 :<nil>

 

7.5 select 语句

 

        select是Go中的一个控制结构，类似于用于通信的switch语句。每个case必须是一个通信操作，要么是发送要么是接收。

        select随机执行一个可运行的case。如果没有case可运行，它将阻塞，直到有case可运行。一个默认的子句应该总是可运行的。

语法

        Go 编程语言中 select 语句的语法如下：

select {

case communication clause :

statement(s);

case communication clause :

statement(s);

/* 你可以定义任意数量的 case */

default : /* 可选 */

statement(s);

}

        以下描述了 select 语句的语法：

 

• 每个case都必须是一个通信
• 所有channel表达式都会被求值
• 所有被发送的表达式都会被求值
• 如果任意某个通信可以进行，它就执行；其他被忽略。
• 如果有多个case都可以运行，Select会随机公平地选出一个执行。其他不会执行。 

 

否则：

1. 如果有default子句，则执行该语句。
2. 如果没有default子句，select将阻塞，直到某个通信可以运行；Go不会重新对channel或值进行求值。

实例

package main


import "fmt"


func main() {

var c1, c2, c3 chan int

var i1, i2 int


select {

case i1 = <-c1:

fmt.Printf("received ", i1, " from c1\n")

case c2 <- i2:

fmt.Printf("sent ", i2, " to c2\n")

case i3, ok := (<-c3): // same as: i3, ok := <-c3

if ok {

fmt.Printf("received ", i3, " from c3\n")

} else {

fmt.Printf("c3 is closed\n")

}

default:

fmt.Printf("no communication\n")

}

}

        以上代码执行结果为：

no communication

转自：http://www.runoob.com/go/go-decision-making.html

https://blog.csdn.net/u012869599/article/details/80383252