11. 流程控制

所谓流程控制就是指“程序怎么执行”或者说“程序执行的顺序”。程序整体上确实是从上往下执行，但又不单纯是从上往下。
流程控制可分为三类：

  1. 顺序执行。这个非常简单，就是先执行第一行再执行第二行……这样依次从上往下执行。
  2. 选择执行。有些代码可以跳过不执行，有选择地执行某些代码。
  3. 循环执行。有些代码会反复执行。

11.1 条件语句

在 Go 中 条件语句模型 如下：

1
2
3
4
5
6
7
8
9
if 条件1 {
  逻辑代码1
} else if  条件2 {
  逻辑代码2
} else if 条件 ... {
  逻辑代码 ...
} else {
  逻辑代码 else
}

如果分支的 condition 为真，则执行该分支 { 和 } 之间的代码。在 Go 中，对于 { 和 } 的位置有严格的要求，它要求 else if (或 else ) 和两边的花括号，必须在同一行。特别注意，即使在 { 和 } 之间只有一条语句，这两个花括号也是不能省略的。

  • 单分支判断

    只有一个 if 为单分支判断：

    1
    2
    3
    4
    score := 88
    if score >= 60 {
        fmt.Println("成绩及格")
    }

  • 双分支判断

    有 if 和一个 else 为两分支判断：

    1
    2
    3
    4
    5
    6
    score := 88
    if score >= 60 {
        fmt.Println("成绩及格")
    } else {
        fmt.Println("成绩不及格")
    }

  • 多分支判断

    有 if 、 else if 以及 else 为多分支判断：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    score := 88
    if score >= 90 {
        fmt.Println("成绩等级为A")
    } else if score >= 80 {
        fmt.Println("成绩等级为B")
    } else if score >= 70 {
        fmt.Println("成绩等级为C")
    } else if score >= 60 {
        fmt.Println("成绩等级为D")
    } else {
        fmt.Println("成绩等级为E 成绩不及格")
    }

  • 条件语句高级写法

    if 还有另外一种写法，它包含一个 statement 可选语句部分，该可选语句在条件判断之前运行。它的语法是：

    1
    2
    if statement; condition {
    }

    上面单分支判断的那个例子可以重写如下：

    1
    2
    3
    if score := 88; score >= 60 {
        fmt.Println("成绩及格")
    }

11.2 选择语句

在 Go 选择语句模型 如下：

1
2
3
4
5
6
7
8
9
10
11
12
switch 表达式 {
    case 表达式值1:
        业务逻辑代码1
    case 表达式值2:
        业务逻辑代码2
    case 表达式值3:
        业务逻辑代码3
    case 表达式值 ...:
        业务逻辑代码 ...
    default:
        业务逻辑代码
}

switch 语句是一个选择语句，用于将 switch 后的表达式的值与可能匹配的选项 case 后的表达式进行比较，并根据匹配情况执行相应的代码块，执行完匹配的代码块后，直接退出 switch-case 。如果没有任何一个匹配，就会执行 default 的代码块。它可以被认为是替代多个 if-else 子句的常用方式。注意：case 不允许出现重复项。例如，下面的例子会输出 Your score is between 80 and 90. 。

1
2
3
4
5
6
7
8
9
10
11
12
13
grade := "B"
switch grade {
case "A":
    fmt.Println("Your score is between 90 and 100.")
case "B":
    fmt.Println("Your score is between 80 and 90.")
case "C":
    fmt.Println("Your score is between 70 and 80.")
case "D":
    fmt.Println("Your score is between 60 and 70.")
default:
    fmt.Println("Your score is below 60.")
}

  • 一个 case 多个条件

    在 Go 中， case 后可以接多个条件，多个条件之间是 或 的关系，用逗号 , 相隔。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    month := 5
    switch month {
    case 1, 3, 5, 7, 8, 10, 12:
        fmt.Println("该月份有 31 天")
    case 4, 6, 9, 11:
        fmt.Println("该月份有 30 天")
    case 2:
        fmt.Println("该月份闰年为 29 天，非闰年为 28 天")
    default:
        fmt.Println("输入有误！")
    }

  • 选择语句高级写法

    switch 还有另外一种写法，它包含一个 statement 可选语句部分，该可选语句在表达式之前运行。它的语法是：

    1
    2
    switch statement; expression {
    }

    可以将上面的例子改写为：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    switch month := 5; month {
    case 1, 3, 5, 7, 8, 10, 12:
        fmt.Println("该月份有 31 天")
    case 4, 6, 9, 11:
        fmt.Println("该月份有 30 天")
    case 2:
        fmt.Println("该月份闰年为 29 天，非闰年为 28 天")
    default:
        fmt.Println("输入有误！")
    }

​ 这里 month 变量的作用域就仅限于这个 switch 内。

  • switch 后可接函数

    switch 后面可以接一个函数，只要保证 case 后的值类型与函数的返回值一致即可。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    package main

    import "fmt"

    func getResult(args ...int) bool {
     for _, v := range args {
      if v < 60 {
       return false
      }
     }
     return true
    }

    func main() {
     chinese := 88
     math := 90
     english := 95

     switch getResult(chinese, math, english) {
     case true:
      fmt.Println("考试通过")
     case false:
      fmt.Println("考试未通过")
     }
    }

  • 无表达式的 switch

    switch 后面的表达式是可选的。如果省略该表达式，则表示这个 switch 语句等同于 switch true ，并且每个 case 表达式都被认定为有效，相应的代码块也会被执行。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    score := 88
    switch {
    case score >= 90 && score <= 100:
        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")
    case score < 60:
        fmt.Println("grade E")
    }

    该 switch-case 语句相当于 if-elseif-else 语句。

  • fallthrough 语句

    正常情况下 switch-case 语句在执行时只要有一个 case 满足条件，就会直接退出 switch-case ，如果一个都没有满足，才会执行 default 的代码块。不同于其他语言需要在每个 case 中添加 break 语句才能退出。使用 fallthrough 语句可以在已经执行完成的 case 之后，把控制权转移到下一个 case 的执行代码中。fallthrough 只能穿透一层，不管你有没有匹配上，都要退出了。fallthrough 语句是 case 子句的最后一个语句。如果它出现在了 case 语句的中间，编译会不通过。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    s := "从0到Go语言微服务架构师"
    switch {
    case s == "从0到Go语言微服务架构师":
        fmt.Println("从0到Go语言微服务架构师")
        fallthrough
    case s == "Go语言微服务架构核心22讲":
        fmt.Println("Go语言微服务架构核心22讲")
    case s != "Go语言极简一本通":
        fmt.Println("Go语言极简一本通")
    }

11.3 循环语句

循环语句 可以用来重复执行某一段代码。在 C 语言中，循环语句有 for 、 while 和 do while 三种循环。但在 Go 中只有 for 一种循环语句。下面是 for 循环语句的四种基本模型：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// for 接三个表达式
for initialisation; condition; post {
   code
}

// for 接一个条件表达式
for condition {
   code
}

// for 接一个 range 表达式
for range_expression {
   code
}

// for 不接表达式
for {
   code
}

接下来我们对每一种模型进行讲解。

  • 接一个条件表达式

    下面的例子利用 for 循环打印 0 到 3 的数值：

    1
    2
    3
    4
    5
    num := 0
    for num < 4 {
        fmt.Println(num)
        num++
    }

  • 接三个表达式

    for 后面接的这三个表达式，各有各的用途：

    • 第一个表达式(initialisation)：初始化控制变量，在整个循环生命周期内，只执行一次；
    • 第二个表达式(condition)：设置循环控制条件，该表达式值为 true 时循环，值为 false 时结束循环；
    • 第三个表达式(post)：每次循环完都会执行此表达式，可以利用其让控制变量增量或减量。

    这三个表达式，使用 ; 分隔。

    1
    2
    3
    for num := 0; num < 4; num++ {
        fmt.Println(num)
    }

    该程序的输出和上面的例子是等价的。这里注意一点，在第一个表达式声明的变量 num 的作用域只在 for 循环里面有效。

  • 接一个 range 表达式

    在 Go 中遍历一个可迭代的对象一般使用 for-range 语句实现，其中 range 后面可以接数组、切片、字符串等， range 会返回两个值，第一个是索引值，第二个是数据值。

    1
    2
    3
    4
    str := "从0到Go语言微服务架构师"
    for index, value := range str{
        fmt.Printf("index %d, value %c\n", index, value)
    }

  • 不接表达式

    for 后面不接表达式就相当于无限循环，当然，可以使用 break 语句退出循环。

    下面两种无限循环的写法等价，但一般使用第一种写法。

    1
    2
    3
    4
    5
    6
    7
    8
    // 第一种写法
    for {
        code
    }
    // 第二种写法
    for ;; {
        code
    }

  • break 语句

    break 语句用于终止 for 循环，之后程序将执行在 for 循环后的代码。上面的例子已经演示了 break 语句的使用。

  • continue 语句

    continue 语句用来跳出 for 循环中的当前循环。在 continue 语句后的所有的 for 循环语句都不会在本次循环中执行，执行完 continue 语句后将会继续执行一下次循环。下面的程序会打印出 10 以内的奇数。

    1
    2
    3
    4
    5
    6
    for num := 1; num <= 10; num++ {
        if num % 2 == 0 {
            continue
        }
        fmt.Println(num)
    }

11.4 defer 延迟调用

含有 defer 语句的函数，会在该函数将要返回之前，调用另一个函数。简单点说就是 defer 语句后面跟着的函数会延迟到当前函数执行完后再执行。

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

import "fmt"

func bookPrint() {
    fmt.Println("Go语言极简一本通")
}

func main() {
defer bookPrint()
    fmt.Println("main函数...")
}

首先，执行 main 函数，因为 bookPrint() 函数前有 defer 关键字，所以会在执行完 main 函数后再执行 bookPrint() 函数，所以先打印出 main函数... ，再执行 bookPrint() 函数打印 Go语言极简一本通 。

关于 defer 有几个注意点，下面依次介绍：

  • 即时求值的变量快照

    使用 defer 只是延时调用函数，传递给函数里的变量，不应该受到后续程序的影响。

    1
    2
    3
    4
    str := "Go语言极简一本通"
    defer fmt.Println(str)
    str = "欢喜"
    fmt.Println(str)

  • 延迟方法

    defer 不仅能够延迟函数的执行，也能延迟方法的执行。

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

    import "fmt"

    type Book struct {
    	bookName, authorName string
    }

    func (b Book) printName() {
    	fmt.Printf("%s %s", b.bookName, b.authorName)
    }

    func main() {
    	book := Book{"《Go语言极简一本通》", "欢喜"}
    	defer book.printName()
    	fmt.Printf("main... ")
    }

  • defer 栈

    当一个函数内多次调用 defer 时，Go 会把 defer 调用放入到一个栈中，随后按照 后进先出 的顺序执行。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    package main

    import "fmt"

    func main() {
    	defer fmt.Printf("从0到Go语言微服务架构师")
    	defer fmt.Printf("Go语言微服务架构核心22讲")
    	defer fmt.Printf("《Go语言极简一本通》")
    	fmt.Printf("main...")
    }

  • defer 在 return 后调用

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

import "fmt"

var s string = "Go语言微服务架构核心22讲"

func showLesson() string {
    defer func() {
        s = "从0到Go语言微服务架构师"
    }()
    fmt.Println("showLesson: s =", s)
    return s
}

func main() {
    lesson := showLesson()
    fmt.Println("main: s =", s)
    fmt.Println("main: lesson =", lesson)
}

  • defer 可以使代码更简洁

    如果没有使用 defer ，当在一个操作资源的函数里调用多个 return 时，每次都得释放资源，你可能这样写代码：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    func f() {
        r := getResource()  //0，获取资源
        ......
        if ... {
            r.release()  //1，释放资源
            return
        }
        ......
        if ... {
            r.release()  //2，释放资源
            return
        }
        ......
        if ... {
            r.release()  //3，释放资源
            return
        }
        ......
        r.release()     //4，释放资源
        return
    }

    有了 defer 之后，你可以简洁地写成下面这样：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    func f() {
        r := getResource()  //0，获取资源

        defer r.release()  //1，释放资源
        ......
        if ... {
            ...
            return
        }
        ......
        if ... {
            ...
            return
        }
        ......
        if ... {
            ...
            return
        }
        ......
        return
    }

11.5 goto 无条件跳转

在 Go 语言中保留 goto 。goto 后面接的是标签，表示下一步要执行哪里的代码。

1
2
3
goto label
...
label: code

下面是使用 goto 的例子：

1
2
3
4
5
6
7
8
9
10
11
package main

import "fmt"

func main() {
	fmt.Println("从0到Go语言微服务架构师")
	goto label
	fmt.Println("Go语言微服务架构核心22讲")
label:
    fmt.Println("《Go语言极简一本通》")
}

goto 语句与标签之间不能有变量声明，否则编译错误。编译下面的程序会报错：

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

import "fmt"

func main() {
	fmt.Println("从0到Go语言微服务架构师")
	goto label
	fmt.Println("Go语言微服务架构核心22讲")
	var x int = 0
label:
    fmt.Println("《Go语言极简一本通》")
}

如何学习Go语言微服务，快速步入架构师

从0到Go语言微服务架构师-海报 从0到Go语言微服务架构师
添加微信 公众号更多内容
wechat gzh