04- Go语言基础之流程控制

流程控制是每种编程语言控制逻辑走向和执行次序的重要部分，流程控制可以说是一门语言的“经脉”。

Go语言中最常用的流程控制有if和for，而switch和goto主要是为了简化代码、降低重复代码而生的结构，属于扩展类的流程控制。

if else (分支结构)

if 条件判断的基础语法.

  1. if 表达式1 {
  2.     分支1
  3. } else if 表达式2 {
  4.     分支2
  5. } else {
  6.     分支3
  7. }

当表达式1的结果为true时，执行分支1，否则判断表达式2，如果满足则执行分支2，都不满足时，则执行分支3。 if判断中的else if和else都是可选的，可以根据实际需要进行选择。

Go语言规定与if匹配的左括号{必须与if和表达式放在同一行，{放在其他位置会触发编译错误。 同理，与else匹配的{也必须与else写在同一行，else也必须与上一个if或else if右边的大括号在同一行。

Demo

  1. func ifDemo() {
  2.     score := 65
  3.     if score >= 90 {
  4.         fmt.Println("A")
  5.     } else if score >75 {
  6.         fmt.Println("B")
  7.     } else {
  8.         fmt.Println("C")
  9.     }
  10. }

if 条件判断的特殊写法

if条件判断还有一种特殊的写法，可以在 if 表达式之前添加一个执行语句，再根据变量值进行判断，举个例子：

  1. func ifDemo2() {
  2.     if score := 65; score >= 90 {
  3.         fmt.Println("A")
  4.     } else if score > 75 {
  5.         fmt.Println("B")
  6.     } else {
  7.         fmt.Println("C")
  8.     }
  9. }

思考题： 上下两种写法的区别在哪里？

  1. // 区别在于, score 的作用域不一样

for (循环结构)

Go 语言中的所有循环类型均可以使用for 关键字完成.

for 循环的基本格式:

  1. for  初始语句; 条件表达式; 结束语句 {
  2.     循环体语句
  3. }

条件表达式返回true时循环体不停地进行循环，直到条件表达式返回false时自动退出循环。

  1. func forDemo() {
  2.     for i := 0; i < 10; i++ {
  3.         fmt.Println(i)
  4.     }
  5. }

for 循环的初始语句可以被忽略, 但是初始语句后的分号必须要写

  1. func forDemo2() {
  2.     i := 0
  3.     for ; i < 10; i++ {
  4.         fmt.Println(i)
  5.     }
  6. }

for循环的初始语句和结束语句都可以省略，例如：

  1. func forDemo3() {
  2.     i := 0
  3.     for i < 10 {
  4.         fmt.Println(i)
  5.         i++
  6.     }
  7. }

这种写法类似于其他编程语言中的 while, 在while 后添加一个表达式, 满足条件表达式时持续循环, 否则结束循环.

无限循环

  1. for {
  2.     循环体语句
  3. }

for循环可以通过break、goto、return、panic语句强制退出循环。

for range (键值循环)

Go 语言可以使用for range 遍历数组, 切片, 字符串, map 及通道(channel). 通过for range遍历的返回值有以下规律:

  • 数组, 切片, 字符串.返回索引和值
  • map 返回 键和值
  • 通道(channel) 只返回通道内的值.

switch case

使用 switch 语句可方便的对大量的值进行条件判断

  1. func switchDemo1() {
  2.     finger := 3
  3.     switch finger {
  4.     case 1:
  5.         fmt.Println("大拇指")
  6.     case 2:
  7.         fmt.Println("食指")
  8.     case 3:
  9.         fmt.Println("中指")
  10.     case 4:
  11.         fmt.Println("无名指")
  12.     case 5:
  13.         fmt.Println("小拇指")
  14.     default:
  15.         fmt.Println("无效的输入！")
  16.     }
  17. }

Go 语言规定 每个switch 只能有一个 default 分支.

一个分支可以有多个值, 多个case值中间使用英文逗号分隔.

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

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

  1. func switchDemo4() {
  2.     age := 30
  3.     switch {
  4.     case age < 25:
  5.         fmt.Println("好好学习吧")
  6.     case age > 25 && age < 35:
  7.         fmt.Println("好好工作吧")
  8.     case age > 60:
  9.         fmt.Println("好好享受吧")
  10.     default:
  11.         fmt.Println("活着真好")
  12.     }
  13. }

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

  1. func switchDemo5() {
  2.     s := "a"
  3.     switch {
  4.     case s == "a":
  5.         fmt.Println("a")
  6.         fallthrough
  7.     case s == "b":
  8.         fmt.Println("b")
  9.     case s == "c":
  10.         fmt.Println("c")
  11.     default:
  12.         fmt.Println("...")
  13.     }
  14. }

输出

  1. a
  2. b

goto 跳转到指定标签

goto 语句通过标签 进行代码间的无条件跳转, goto 语句可以在 快速跳出循环. 避免重复退出上有一定的帮助. Go 语言中使用goto 能简化一些代码的实现过程.

例: 双层嵌套的for循环要退出时

  1. func gotoDemo() {
  2.     for a:=1; a<20; a++ {
  3.         for b:=2; b<10; b++ {
  4.             if a == b {
  5.                 fmt.Println(a)
  6.                 goto breakTag
  7.             }
  8.         }
  9.     }
  10. breakTag:
  11.     fmt.Println("我结束了")
  12. }

break 跳出循环

break 语句可以结束 for switch select 的代码库

break 语句还可以在语句后面添加标签, 表示退出某个标签对应的代码块, 标签要求必须定义在对应的 switch 和 select 代码块之上,

例如:

  1. func breakDemo() {
  2. BreakTag:
  3.     for a:=1; a<10; a++ {
  4.         for b:=2; b<20; b++ {
  5.             if b ==10 {
  6.                 break BreakTag
  7.             }
  8.             fmt.Printf("%v-%v\n", a, b)
  9.         }
  10.     }
  11.     fmt.Println("结束了")
  13. }

continue 继续下次循环

continue 语句可以结束当前循环, 开始下次的循环迭代过程, 仅限在for 循环内使用.

在 continue 语句后添加标签时, 表示开始标签对应的循环.

  1. func continueDemo() {
  2. forloop1:
  3.     for i := 0; i < 5; i++ {
  4.         // forloop2:
  5.         for j := 0; j < 5; j++ {
  6.             if i == 2 && j == 2 {
  7.                 continue forloop1
  8.             }
  9.             fmt.Printf("%v-%v\n", i, j)
  10.         }
  11.     }
  12. }