Go 语言快速入门指南：第二篇 变量与常量

上一章中，我们学会了变量与常量，为了让我们的程序更加贴近实际生活，有时候我们需要做决定。Go 提供了如下三种控制结构：

• if/else 语句

• switch 语句

• for 语句

假设我们需要打印 1-5 的五个数，基于前面所学的知识，可能会写出如下的代码：

package main

import "fmt"

func main() {
    fmt.Println(1)
    fmt.Println(2)
    fmt.Println(3)
    fmt.Println(4)
    fmt.Println(5)
}

可以看到，我们重复写了很多简单的代码，这对于程序员来说，是绝对不可以容忍的，那么有什么好的办法嘛，答案是有的。

1Go 的流程控制

生活中，我们做事情也需要有流程，比如炒菜：可能需要先放油，然后炒菜，放盐，尝味，起锅...

程序也一样，我们利用流程控制就可以做一些复杂的代码逻辑设计了。那么，Go 语言的流程控制是咋样的呢？

Go 语言在流程控制特点：

• 没有 do 和 while 循环，只有一个功能丰富的 ​​for​​ 语句

• ​​switch​​ 语句灵活多变，还可以用于类型判断

• ​​if​​​ 语句和 ​​switch ​​语句都可以包含一条初始化语句

• ​​break​​​ 语句和 ​​continue​​ 语句后面可以跟一条标签语句，以标识需要终止或继续的代码块

• ​​defer​​ 语句可以使我们更加方便地执行异常捕获和资源回收任务

• ​​select ​​语句也可用于多分支选择，但只能与通道配合使用

• go​​​ 语句用于异步启用 ​​goroutine​​ 并执行指定函数

2for 语句

​​for​​​ 语句允许我们多次重复一个语句列表（一个块）。 使用 ​​for​​ 语句简化打印 5 个数的程序：

package main

import "fmt"

func main() {
    i := 1
    for i <= 5 {
        fmt.Println(i)
        i += 1  // 等于 i = i + 1
    }
}

代码解释：

• 首先，创建一个名为 i 的变量，用于存储需要打印的数字

• 然后，使用 ​​for​​ 关键字创建一个 5 次的循环，如果 i 少于等于5次，就执行 ​​for​​ 语句块里的程序

• 最后，执行打印语句，打印完让 i 加 1

详细过程：

1. 第一次：i = 1，i <= 5? 是的，打印 1。 i = i + 1，此时 i = 2

2. 第二次：i = 2, i <= 5? 是，打印 2。i += 1，此时 i = 3

3. ...

4. ...

5. 第五次，i = 5，i <= 5? 是,打印5 。i += 1, 此时 i = 6

6. 第六次，i = 6，i <= 5 ？否，退出 for 语句块，程序结束

代码还可以简化一下，直接把 i 的定义写在 for 语句中：

func main() {
    for i := 1; i <= 5; i++ {
        fmt.Println(i)
    }
}

练习计算 1+2+3+...+100 的总和，代码如下：

package main

import "fmt"

func main() {
    number := 0
    for i := 0; i <= 100; i++ {
        number += i
    }
    fmt.Println("1+2+3+...+100 = ", number)
}

执行如下：

$ go run main.go
1+2+3+...+100 =  5050

3if 语句

如果我们不想打印连续的 5 个数，而是想打印 5 个奇数，应该如何处理呢？

伪代码如下：

// 伪代码
if i is odd {
    fmt.Println(i)
}

​​if​​​ 语句此时派上用场了，if 功能就像是如果，即满足该条件的话，我们使用啥。​​if​​​ 语句有一个可选的 ​​else​​​ 部分。 如果条件评估为真，则运行条件之后的块，否则跳过该块，或者如果存在 ​​else​​​ 块，则运行 ​​else​​ 部分的代码块。

// 伪代码
if i is odd {
    fmt.Println(i)
} else {
    fmt.Println(i) // i is even
}

此时，打印奇数的代码就可以顺利写出来：

package main

import "fmt"

func main() {
    for i := 0; i < 10; i++ {
        if i%2 != 0 {
            fmt.Println("奇数:", i)
        } else {
            // fmt.Println("偶数:", i)
        }
    }
}

if​​ 语句还可以包含一条初始化子语句，用于初始化局部变量:

if num := 1; num <= 5 {
    num++
    fmt.Println(num)
}

4switch 语句

假设我们想编写一个程序来打印星期的英文名称。 使用我们到目前为止学到的知识，我们可以从这样做开始。

var Weekday int

if Weekday == 0 {
    fmt.Println("Sunday")
} else if Weekday == 1 {
    fmt.Println("Monday")
} else if Weekday == 2 {
    fmt.Println("Tuesday")
} else if Weekday == 3 {
    fmt.Println("Wednesday")
} else if Weekday == 4 {
    fmt.Println("Thursday")
} else if Weekday == 5 {
    fmt.Println("Friday")
} else if Weekday == 6 {
    fmt.Println("Saturday")
}

由于以这种方式编写程序会非常乏味，因此 Go 提供了另一个语句来简化此过程：​​switch​​ 语句。 我们可以将我们的程序改写成这样：

package main

import "fmt"

func main() {
    var (
        Weekday int
    )
    fmt.Print("请输入数字: ")
    fmt.Scanln(&Weekday)

    switch Weekday {
    case 0: // Sunday
        fmt.Println("Sunday")
    case 1: // Monday
        fmt.Println("Monday")
    case 2: // Tuesday
        fmt.Println("Tuesday")
    case 3: // Wednesday
        fmt.Println("Wednesday")
    case 4: // Thursday
        fmt.Println("Thursday")
    case 5: // Friday
        fmt.Println("Friday")
    case 6: // Saturday
        fmt.Println("Saturday")
    }
}

运行上面的程序，如下：

$ go run main.go
请输入数字: 4
Thursday

switch​​​ 语句以关键字 ​​switch​​​ 开始，后跟表达式（在本例中为 Weekday ），然后是一系列 ​​case​​​。 表达式的值与每个 ​​case​​​ 关键字后面的表达式进行比较。 如果它们相等，则执行​​ :​​ 之后的语句。

就像​​if​​​ 语句一样，每个 ​​case​​​ 都会自上而下地检查，然后选择第一个成功的 ​​case​​​ 。 ​​switch​​​ 还支持 ​​default​​​ 情况，如果没有任何情况与值匹配，就会发生这种情况，即如果我们输入了除了 0-6 之外的数字，就会允许 ​​default​​ 块。

switch Weekday {
    default:
    fmt.Println("Unknow Weekday")
    case 0:
    fmt.Println("Sunday")
}

5defer 语句

defer​​ 语句推迟函数的执行并将函数调用推送到列表中，直到周围的函数正常或通过 panic 返回。 defer 通常用于简化执行各种清理操作的函数，如下所示：

package main

import "fmt"

func main() {

    defer fmt.Println("Starting")

    fmt.Println("Everything")
}

该代码运行会得到先打印后面一句，然后再打印前一句的结果，即：

Everything
Starting

6代码块和作用域

代码块：由一个花括号包裹的表达式和语句的序列。代码块也可以为空——空代码块。还有一些隐式代码块，如：

• 所有 Go 代码形成一个最大的代码块，即：全域代码块

• 每个代码包中的代码共同组成了一个代码块，即：代码包代码块

• 每一个源码文件都是一个代码块，即：源码文件代码块

• 每一个 if、for、switch 和 select 语句都是一个代码块

• 每一个在 switch 或 select 语句中的 case 分支都是一个代码块

作用域：使用代码块表示词法上的作用域范围

• 一个预定义标识符的作用域是全域代码块

• 表示一个常量、变量、类型或函数（不包括方法），且声明在函数之外的标识符的作用域是当前的代码包代码块

• 被导入的代码包的名称的作用域是当前源码文件代码块

• 表示方法接收者、方法参数或方法结果的标识符的作用域是当前的方法代码块

• 对于表示常量、变量、类型或函数的标识符，如果声明在函数内部，那么作用域就是包含其声明的那个最内层的代码块。

7总结

• ​​if​​ 语句需要一个精确的布尔表达式。 没有“真”或“假”。

• ​​if​​ 语句可能有一个类似于 for 语句第一部分的前置表达式。

• ​​switch​​​ 语句不需要 ​​break​​ ，默认情况下不会失败。

• ​​switch​​ 语句每个 case 可以有多个值。

• 使用 ​​||​​​ “or” 和 ​​&&​​ “and” 用于复杂条件的运算符

• defer​​ 语句推迟函数的执行并将函数调用推送到列表中

当我们学会流程控制之后，就能在程序中做各种各样的决定了，赶紧用起来。