第04章 - 流程控制与函数

本章讲解 Go 的流程控制语句（条件、循环、分支）以及函数的定义与高级用法，包括多返回值、可变参数、闭包和 defer 机制。

4.1 条件语句 if

Go 的 if 语句不需要括号包裹条件，但花括号是必须的：

score := 85
if score >= 90 {
    fmt.Println("优秀")
} else if score >= 60 {
    fmt.Println("及格")
} else {
    fmt.Println("不及格")
}

4.1.1 带初始化语句的 if

if 可以在条件前包含一个初始化语句，该语句声明的变量作用域仅限于 if-else 块内，这是 Go 非常地道的写法：

if value, err := strconv.Atoi("123"); err == nil {
    fmt.Println("转换成功:", value)
} else {
    fmt.Println("转换失败:", err)
}
// value 和 err 在这里已不可见

这种模式将变量作用域限制在最小范围，是处理错误的标准方式。

4.2 循环语句 for

Go 只有一种循环关键字 for，但它能表达所有循环形式。

4.2.1 经典三段式

for i := 0; i < 10; i++ {
    fmt.Println(i)
}

4.2.2 类 while 循环

省略初始化和后置语句，for 就相当于 while：

n := 1
for n < 100 {
    n *= 2
}

4.2.3 无限循环

for {
    // 永久循环，通常配合 break 或 return 退出
    if done {
        break
    }
}

4.2.4 range 遍历

range 用于遍历数组、切片、字符串、map 和 channel：

nums := []int{10, 20, 30}
for index, value := range nums {
    fmt.Printf("索引 %d = %d\n", index, value)
}

// 只要索引
for index := range nums {
    fmt.Println(index)
}

// 只要值，用下划线忽略索引
for _, value := range nums {
    fmt.Println(value)
}

// 遍历 map
m := map[string]int{"a": 1, "b": 2}
for key, val := range m {
    fmt.Println(key, val)
}

4.3 跳转语句

• break：跳出当前循环或 switch。
• continue：跳过本次循环，进入下一次迭代。
• goto：跳转到指定标签（极少使用）。
• 标签（label）：配合 break/continue 可跳出多层嵌套循环：

outer:
for i := 0; i < 3; i++ {
    for j := 0; j < 3; j++ {
        if i*j > 2 {
            break outer // 直接跳出外层循环
        }
    }
}

4.4 分支语句 switch

Go 的 switch 比 C 更强大，且默认不需要 break——每个 case 执行完自动跳出。

switch day {
case "Sat", "Sun": // 一个 case 可匹配多个值
    fmt.Println("周末")
default:
    fmt.Println("工作日")
}

4.4.1 表达式 switch

switch 后可以不跟变量，此时相当于 if-else 链：

switch {
case score >= 90:
    fmt.Println("A")
case score >= 80:
    fmt.Println("B")
default:
    fmt.Println("C")
}

4.4.2 fallthrough

若希望继续执行下一个 case（C 语言的默认行为），可使用 fallthrough：

switch n {
case 1:
    fmt.Println("one")
    fallthrough
case 2:
    fmt.Println("two") // 当 n==1 时也会执行
}

4.4.3 类型 switch

用于判断接口的动态类型（详见第 6 章）：

switch v := i.(type) {
case int:
    fmt.Println("整数:", v)
case string:
    fmt.Println("字符串:", v)
default:
    fmt.Println("未知类型")
}

4.5 函数定义

函数使用 func 关键字定义，基本语法为 func 函数名(参数列表) 返回值类型 { 函数体 }：

func add(a int, b int) int {
    return a + b
}

// 相同类型的参数可合并书写
func add(a, b int) int {
    return a + b
}

4.5.1 多返回值

Go 函数可以返回多个值，这是其一大特色，广泛用于"返回结果 + 错误"的模式：

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("除数不能为零")
    }
    return a / b, nil
}

result, err := divide(10, 2)
if err != nil {
    fmt.Println("错误:", err)
    return
}
fmt.Println("结果:", result)

4.5.2 命名返回值

返回值可以命名，相当于在函数开头声明了这些变量，return 时可不带参数（裸返回）：

func split(sum int) (x, y int) {
    x = sum * 4 / 9
    y = sum - x
    return // 裸返回，返回 x 和 y
}

命名返回值能提升可读性，但裸返回在长函数中会降低可读性，应谨慎使用。

4.5.3 可变参数

参数类型前加 ... 表示可变参数，函数内部将其视为切片：

func sum(nums ...int) int {
    total := 0
    for _, n := range nums {
        total += n
    }
    return total
}

sum(1, 2, 3)         // 6
sum(1, 2, 3, 4, 5)   // 15

// 将切片展开传入
s := []int{1, 2, 3}
sum(s...)

4.6 函数是一等公民

在 Go 中，函数是一等公民（first-class citizen），可以赋值给变量、作为参数传递、作为返回值返回。

// 函数类型变量
var op func(int, int) int
op = add
fmt.Println(op(3, 4))

// 函数作为参数（回调）
func apply(a, b int, fn func(int, int) int) int {
    return fn(a, b)
}

4.6.1 匿名函数与闭包

匿名函数可以捕获外部变量，形成闭包：

func counter() func() int {
    count := 0
    return func() int {
        count++       // 捕获并修改外部变量
        return count
    }
}

c := counter()
fmt.Println(c()) // 1
fmt.Println(c()) // 2
fmt.Println(c()) // 3

每次调用 counter() 都会创建一个独立的 count 变量，闭包持有对它的引用。

4.7 defer 延迟执行

defer 用于延迟执行一个函数调用，被延迟的调用会在外层函数返回前执行，常用于资源释放、解锁、关闭文件等场景：

func readFile(name string) error {
    f, err := os.Open(name)
    if err != nil {
        return err
    }
    defer f.Close() // 函数返回前自动关闭文件

    // ... 处理文件 ...
    return nil
}

4.7.1 defer 的执行顺序

多个 defer 按后进先出（LIFO）的栈顺序执行：

func main() {
    for i := 0; i < 3; i++ {
        defer fmt.Println(i)
    }
}
// 输出: 2 1 0

4.7.2 defer 参数的求值时机

defer 语句的参数在 defer 出现时立即求值，而非执行时：

func example() {
    i := 0
    defer fmt.Println("defer 中的 i:", i) // 此时 i 为 0
    i = 100
    // 输出: defer 中的 i: 0
}

defer 还能配合命名返回值修改返回结果，这是实现 recover 错误恢复的关键（详见第 7 章）。

4.8 本章小结

本章学习了 Go 的流程控制（if、for、switch）和函数。Go 用单一的 for 表达所有循环，switch 默认自动 break 且支持类型判断。函数支持多返回值、可变参数、闭包，并通过 defer 优雅地管理资源释放。这些特性共同构成了 Go 简洁而强大的控制流。

下一章我们将深入复合数据类型：数组、切片、map 和结构体。