第 9 章：函数

9.1 什么是函数？函数的定义与调用

函数是一段完成特定任务的代码块，它可以被重复调用，提高代码的复用性和可维护性。

函数定义

func functionName(parameters) returnType {
    // 函数体
    return value
}

函数调用

result := functionName(arguments)

示例

package main

import "fmt"

// 定义一个函数，用于计算两个数的和
func add(a, b int) int {
    return a + b
}

func main() {
    // 调用函数
    sum := add(3, 5)
    fmt.Println("3 + 5 =", sum)
}

9.2 函数参数：普通参数、不定长参数

普通参数

func greet(name string, age int) {
    fmt.Printf("Hello, %s! You are %d years old.\n", name, age)
}

不定长参数

不定长参数允许函数接收任意数量的参数：

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

// 调用
fmt.Println(sum(1, 2, 3, 4, 5)) // 输出 15

9.3 函数返回值：单返回值、多返回值（Go 特色）

单返回值

func square(x int) int {
    return x * x
}

多返回值（Go 特色）

Go 语言支持函数返回多个值，这是它的一个特色：

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("division by zero")
    }
    return a / b, nil
}

// 调用
result, err := divide(10, 2)
if err != nil {
    fmt.Println("Error:", err)
} else {
    fmt.Println("Result:", result)
}

9.4 匿名函数与闭包（入门）

匿名函数

匿名函数是没有名字的函数，可以直接定义和调用：

func main() {
    // 定义并立即调用匿名函数
    func() {
        fmt.Println("Hello from anonymous function!")
    }()
    
    // 赋值给变量
    greet := func(name string) {
        fmt.Printf("Hello, %s!\n", name)
    }
    
    greet("Alice")
}

闭包

闭包是可以捕获外部变量的函数：

func counter() func() int {
    count := 0
    return func() int {
        count++
        return count
    }
}

func main() {
    c := counter()
    fmt.Println(c()) // 输出 1
    fmt.Println(c()) // 输出 2
    fmt.Println(c()) // 输出 3
}

9.5 函数作为参数

在 Go 中，函数可以作为参数传递给其他函数：

func apply(op func(int, int) int, a, b int) int {
    return op(a, b)
}

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

func multiply(a, b int) int {
    return a * b
}

func main() {
    fmt.Println(apply(add, 3, 4))      // 输出 7
    fmt.Println(apply(multiply, 3, 4)) // 输出 12
    
    // 也可以使用匿名函数
    fmt.Println(apply(func(a, b int) int {
        return a - b
    }, 10, 3)) // 输出 7
}

9.6 defer 延迟执行（Go 核心特性）

defer 语句用于延迟执行函数调用，直到包含它的函数返回：

基本用法

func main() {
    defer fmt.Println("World")
    fmt.Println("Hello")
}
// 输出：
// Hello
// World

多个 defer 语句

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

func main() {
    defer fmt.Println("1")
    defer fmt.Println("2")
    defer fmt.Println("3")
    fmt.Println("Hello")
}
// 输出：
// Hello
// 3
// 2
// 1

实际应用

defer 常用于资源清理，如关闭文件、释放锁等：

func readFile(filename string) {
    file, err := os.Open(filename)
    if err != nil {
        fmt.Println("Error opening file:", err)
        return
    }
    defer file.Close() // 确保文件被关闭
    
    // 读取文件内容
    // ...
}