Go从入门到放弃之流程控制

阅读目录

• 概述
• 一、条件语句
• 二、分支语句
• 三、循环语句
• 四、注意事项

回到顶部

概述

流程控制主要用于设定计算执行的次序，建立程序的逻辑结构。Go 语言的流程控制和其他编程语言类似，支持如下几种流程控制语句：

• 条件语句：用于条件判断，对应的关键字有 if、else 和 else if；
• 分支语句：用于分支选择，对应的关键字有 switch、case 和 select（用于通道，后面介绍协程时会提到）；
• 循环语句：用于循环迭代，对应的关键字有 for 和 range；
• 跳转语句：用于代码跳转，对应的关键字有 goto。

回到顶部

一、条件语句

条件语句的示例模板如下：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

// if if condition {     // do something }   // if...else... if condition {     // do something } else {     // do something }   // if...else if...else... if condition1 {     // do something } else if condition2 {     // do something else } else {     // catch-all or default }

一个简单的条件语句示例代码如下：

?

1 2 3 4 5 6 7 8 9 10 11 12

score := 100 if score > 90 {     fmt.Println("Grade: A") } else if score > 80 {     fmt.Println("Grade: B") } else if score > 70 {     fmt.Println("Grade: C") } else if score > 60 {     fmt.Println("Grade: D") } else {     fmt.Println("Grade: F") }

注意事项

关于 Go 语言的条件语句，需要注意以下几点：

• 条件语句不需要使用圆括号将条件包含起来 ()；
• 无论语句体内有几条语句，花括号 {} 都是必须存在的；
• 左花括号 { 必须与 if 或者 else 处于同一行；
• 在 if 之后，条件语句之前，可以添加变量初始化语句，使用 ; 间隔，比如上述代码可以这么写 if score := 100; score > 90 {

回到顶部

二、分支语句

分支语句会根据传入条件的不同，选择不同的分支代码执行。

Go 语言的分支语句和其他编程语言类似，只是不需要在每个分支结构中显式通过 break 语句退出：

?

1 2 3 4 5 6 7 8

switch var1 {     case val1:         ...     case val2:         ...     default:         ... }

通过分支语句改写if语句的示例代码：　　

?

1 2 3 4 5 6 7 8 9 10 11 12 13

score := 100 switch { case score >= 90:     fmt.Println("Grade: A") case score >= 80 && score < 90:     fmt.Println("Grade: B") case score >= 70 && score < 80:     fmt.Println("Grade: C") case score >= 60 && score < 70:     fmt.Println("Grade: D") default:     fmt.Println("Grade: F") }

注意这个时候，不能把变量 score 放到 switch 关键字后面，否则会报错，只有在与 case 分支值判等的时候，才可以这么做：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14

score := 100 switch score { case 90, 100:     fmt.Println("Grade: A") case 80:     fmt.Println("Grade: B") case 70:     fmt.Println("Grade: C") case 60: case 65:     fmt.Println("Grade: D") default:     fmt.Println("Grade: F") }

合并分支

 在 Go 语言中，我们可以用逗号分隔不同的分支条件来达到合并分支语句的目的，如 case 90,100，而不能像其它语言那样，通过多个相邻的 case 语句来合并相同的分支语句

?

1 2 3 4 5 6 7 8 9 10

func testSwitch() {     switch n := 7; n {     case 1, 3, 5, 7, 9:         fmt.Println("奇数")     case 2, 4, 6, 8:         fmt.Println("偶数")     default:         fmt.Println(n)     } }

分支还可以使用表达式，这时候switch语句后面不需要再跟判断变量

?

1 2 3 4 5 6 7 8 9 10 11 12 13

func switchDemo4() {     age := 30     switch {     case age < 25:         fmt.Println("好好学习吧")     case age > 25 && age < 35:         fmt.Println("好好工作吧")     case age > 60:         fmt.Println("好好享受吧")     default:         fmt.Println("活着真好")     } }

fallthrough

fallthrough语法可以执行满足条件的case的下一个case，是为了兼容C语言中的case设计的。

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14

func switchDemo5() {     s := "a"     switch {     case s == "a":         fmt.Println("a")         fallthrough     case s == "b":         fmt.Println("b")     case s == "c":         fmt.Println("c")     default:         fmt.Println("...")     } }<br><br>输出：<br><code class=" language-bash">　　a<br></code><code class=" language-bash">　　b</code>

注意事项

在 Go 语言中使用 switch...case... 分支语句时，需要注意以下几点：

• 和条件语句一样，左花括号 { 必须与 switch 处于同一行；
• 单个 case 中，可以出现多个结果选项（通过逗号分隔）；
• 与其它语言不同，Go 语言不需要用 break 来明确退出一个 case；
• 只有在 case 中明确添加 fallthrough 关键字，才会继续执行紧跟的下一个 case；
• 可以不设定 switch 之后的条件表达式，在这种情况下，整个 switch 结构与多个 if...else... 的逻辑作用等同。

回到顶部

三、循环语句

for 循环

Go 语言中的循环语句只支持 for 关键字，而不支持 while 和 do-while 结构。关键字 for 的基本使用方法与其他语言类似，只是循环条件不含括号，比如我们要计算 1 到 100 之间所有数字之和，可以这么做：

?

1 2 3 4 5 6 7

//for 初始语句;条件表达式;结束语句{ //    循环体语句 //}sum := 0 for i := 1; i <= 100; i++ {     sum += i } fmt.Println(sum)

无限循环

Go 语言不支持 while 和 do-while 循环语句，对于无限循环场景，可以通过不带循环条件的 for 语句实现，下面我们通过无限循环来改写上述计算 1 到 100 以内数字之和的实现如下：

 

?

1 2 3 4 5 6 7 8 9 10 11 12

//for { //    循环体语句 //}// sum := 0 i := 0 for {     i++     if i > 100 {         break     }     sum += i } fmt.Println(sum)

for-range 结构

Go 语言还支持通过 for-range 结构对其进行循环遍历,一下为示例

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

遍历切片 a := []int{1, 2, 3, 4, 5, 6} for k, v := range a {     fmt.Println(k, v) }     忽略索引/键 for _, v := range a {     fmt.Println(v) }   忽略元素值 for k := range a {     fmt.Println(k) }

基于条件判断进行循环

基于条件判断进行循环，只有满足指定的条件才会执行循环体中的代码　　

?

1 2 3 4 5 6 7

sum := 0 i := 0 for i < 100 {     i++     sum += i } fmt.Println(sum)

goto

goto语句通过标签进行代码间的无条件跳转。goto语句可以在快速跳出循环、避免重复退出上有一定的帮助。Go语言中使用goto语句能简化一些代码的实现过程。 例如双层嵌套的for循环要退出时：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

func gotoDemo1() {     var breakFlag bool     for i := 0; i < 10; i++ {         for j := 0; j < 10; j++ {             if j == 2 {                 // 设置退出标签                 breakFlag = true                 break             }             fmt.Printf("%v-%v\n", i, j)         }         // 外层for循环判断         if breakFlag {             break         }     } }

使用goto语句能简化代码：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

func gotoDemo2() {     for i := 0; i < 10; i++ {         for j := 0; j < 10; j++ {             if j == 2 {                 // 设置退出标签                 goto breakTag             }             fmt.Printf("%v-%v\n", i, j)         }     }     return     // 标签 breakTag:     fmt.Println("结束for循环") }

回到顶部

四、注意事项

在 Go 语言中使用循环语句时，需要注意以下几点：

• 和条件语句、分支语句一样，左花括号 { 必须与 for 处于同一行；
• 不支持 whie 和 do-while 结构的循环语句；
• 可以通过 for-range 结构对可迭代集合进行遍历；
• 支持基于条件判断进行循环迭代；
• 允许在循环条件中定义和初始化变量，且支持多重赋值；
• Go 语言的 for 循环同样支持 continue 和 break 来控制循环，但是它提供了一个更高级的 break，可以选择中断哪一个循环，如下例：

?

1 2 3 4 5 6 7 8 9

JLoop: for j := 0; j < 5; j++ {     for i := 0; i < 10; i++ {         if i > 5 {             break JLoop         }         fmt.Println(i)     } }