Go 函数：把重复的事交给它
如果你仔细观察日常生活，你会发现很多事情都是重复的。每天早上你要泡咖啡，每周五你要写周报，每个月你要交房租。重复的事情做多了，你就会想：能不能把这些步骤打包，以后只需要一个指令就能搞定？
这就是函数（function）的核心思想。函数就是一段可以重复使用的代码块，你给它起个名字，定义好它需要接收什么输入、产生什么输出，以后随时可以调用它。
Go 语言的函数设计非常优雅。它既不像 C 语言那样简陋，也不像某些面向对象语言那样搞出一大堆复杂的概念。Go 的函数简单、强大，还有一些独特的特性，让我们一起来看看吧。
基本的函数定义
Go 语言使用 func 关键字来定义函数。基本的语法结构是：
func 函数名(参数列表) 返回类型 {
// 函数体
return 返回值
}
来看一个简单的例子：
package main
import "fmt"
// 定义一个函数，计算两个数的和
func add(a int, b int) int {
return a + b
}
func main() {
result := add(3, 5)
fmt.Println("3 + 5 =", result) // 3 + 5 = 8
}
这里有几个要点：
- add 是函数名
- (a int, b int) 是参数列表，声明了两个 int 类型的参数
- 参数列表后面的 int 是返回类型，表示这个函数返回一个整数
- return a + b 返回计算结果
参数类型简写
如果相邻的参数类型相同，可以只在最后一个参数后面声明类型：
func add(a, b int) int {
return a + b
}
这和 func add(a int, b int) int 是完全等价的，只是写法更简洁。
多返回值
这是 Go 语言最让人称道的特性之一。Go 的函数可以返回多个值，这在实际开发中非常实用。
最常见的用法是同时返回结果和错误：
package main
import (
"errors"
"fmt"
)
// divide 执行除法运算，返回商和错误
func divide(a, b float64) (float64, error) {
if b == 0 {
return 0, errors.New("除数不能为 0")
}
return a / b, nil
}
func main() {
// 正常情况
result, err := divide(10, 3)
if err != nil {
fmt.Println("错误:", err)
} else {
fmt.Printf("10 ÷ 3 = %.2f\n", result)
}
// 输出：10 ÷ 3 = 3.33
// 异常情况
result, err = divide(10, 0)
if err != nil {
fmt.Println("错误:", err)
} else {
fmt.Printf("10 ÷ 0 = %.2f\n", result)
}
// 输出：错误: 除数不能为 0
}
注意第 9 行的 return a / b, nil——nil 表示没有错误。这是 Go 语言中非常常见的模式：函数返回一个有用的值和一个错误信息。调用者先检查错误，再使用值。
你会在 Go 的标准库和第三方库中到处看到这种模式。可以说，这是 Go 语言错误处理哲学的基石。
忽略返回值
如果你只关心其中一个返回值，可以用 _（空白标识符）忽略不需要的：
result, _ := divide(10, 3)
fmt.Println(result) // 3.3333333333333335
小贴士：虽然可以用 _ 忽略错误，但在生产代码中不建议这么做。忽略错误就像蒙着眼睛开车——你不知道什么时候会撞上什么东西。
命名返回值
Go 允许你给返回值起名字。命名后的返回值会自动声明为函数内部的变量，你可以在函数体中修改它们：
func swap(a, b int) (first, second int) {
first = b
second = a
return // 裸返回（naked return），自动返回命名返回值
}
func main() {
x, y := swap(1, 2)
fmt.Println(x, y) // 2 1
}
注意第 4 行的 return 后面什么都没写——这叫做裸返回（naked return）。Go 会自动返回命名返回值的当前值。
踩坑提示：裸返回只适合非常短的函数。在长函数中，裸返回会让代码变得难以理解，因为你不知道返回的是什么值。Go 官方建议在长函数中使用显式返回。
可变参数
有时候你不确定函数会接收多少个参数。Go 支持可变参数（variadic parameters），让你可以传入任意数量的参数：
func sum(nums ...int) int {
total := 0
for _, num := range nums {
total += num
}
return total
}
func main() {
fmt.Println(sum(1, 2)) // 3
fmt.Println(sum(1, 2, 3)) // 6
fmt.Println(sum(1, 2, 3, 4, 5)) // 15
}
nums …int 表示 nums 是一个可变参数，它实际上是一个 []int 切片。
如果你已经有了一个切片，可以用 … 把它展开后传给可变参数函数：
numbers := []int{1, 2, 3, 4, 5}
total := sum(numbers...) // 注意这里的 ...
fmt.Println(total) // 15
一个实际的例子——用 fmt.Sprintf 格式化字符串：
func logMessage(level string, args ...interface{}) string {
prefix := "[" + level + "] "
return prefix + fmt.Sprint(args...)
}
msg := logMessage("INFO", "服务器启动，端口：", 8080)
fmt.Println(msg) // [INFO] 服务器启动，端口：8080
函数作为值和参数
在 Go 语言中，函数是一等公民（first-class citizen）。这意味着函数可以像普通值一样被传递、赋值和返回。
package main
import "fmt"
// 定义一个函数类型
type operation func(int, int) int
func add(a, b int) int { return a + b }
func multiply(a, b int) int { return a * b }
// calculate 接收一个函数作为参数
func calculate(op operation, a, b int) int {
return op(a, b)
}
func main() {
fmt.Println(calculate(add, 3, 5)) // 8
fmt.Println(calculate(multiply, 3, 5)) // 15
}
在这个例子中，calculate 函数接收另一个函数作为参数。这种接受函数作为参数或返回函数的函数，叫做高阶函数（higher-order function）。
匿名函数
你可以定义没有名字的函数（匿名函数），直接赋值给变量或者立即执行：
// 赋值给变量
greet := func(name string) string {
return "你好，" + name + "！"
}
fmt.Println(greet("张三")) // 你好，张三！
// 立即执行（IIFE）
result := func(a, b int) int {
return a * b
}(3, 5)
fmt.Println(result) // 15
匿名函数在需要简短逻辑但又不想单独定义一个命名函数的时候特别有用。
闭包
闭包（closure）是匿名函数的一个重要特性。闭包可以记住并访问它定义时所在作用域的变量，即使那个作用域已经结束了。
这听起来有点抽象，看个例子就明白了：
package main
import "fmt"
func makeCounter() func() int {
count := 0 // 这个变量会被闭包记住
return func() int {
count++
return count
}
}
func main() {
counter := makeCounter()
fmt.Println(counter()) // 1
fmt.Println(counter()) // 2
fmt.Println(counter()) // 3
// 再创建一个新的计数器
counter2 := makeCounter()
fmt.Println(counter2()) // 1（独立的计数）
}
在这个例子中，makeCounter 返回了一个匿名函数。这个匿名函数引用了外部的 count 变量。正常情况下，makeCounter 执行完毕后，count 变量应该被销毁。但因为闭包的存在，count 被保留了下来。
每次调用 counter() 时，它都能记住上一次 count 的值，所以会依次返回 1、2、3。
闭包的实际应用
闭包在实际开发中有很多用途。一个常见的场景是创建带状态的处理器：
package main
import "fmt"
// 创建一个限流器，每 n 次调用后执行一次回调
func makeThrottle(n int, callback func()) func() {
count := 0
return func() {
count++
if count%n == 0 {
callback()
}
}
}
func main() {
throttle := makeThrottle(3, func() {
fmt.Println("已处理 3 个请求！")
})
for i := 1; i <= 10; i++ {
fmt.Printf("处理请求 %d\n", i)
throttle()
}
}
// 输出：
// 处理请求 1
// 处理请求 2
// 处理请求 3
// 已处理 3 个请求！
// ...
defer：延迟执行
defer 是 Go 语言中一个非常独特且实用的关键字。被 defer 修饰的语句不会立即执行，而是推迟到当前函数返回之前才执行。
package main
import "fmt"
func main() {
fmt.Println("第一行")
defer fmt.Println("第二行（defer）")
fmt.Println("第三行")
}
// 输出：
// 第一行
// 第三行
// 第二行（defer）
注意执行顺序：defer 语句被推迟到了函数最后才执行。
defer 的执行顺序
如果有多个 defer 语句，它们会按照后进先出（LIFO）的顺序执行：
func main() {
defer fmt.Println("1")
defer fmt.Println("2")
defer fmt.Println("3")
}
// 输出：
// 3
// 2
// 1
就像叠盘子一样——最后放上去的盘子最先被拿走。
defer 的常见用法
1. 关闭文件
这是 defer 最经典的用途：
func readFile(filename string) ([]byte, error) {
f, err := os.Open(filename)
if err != nil {
return nil, err
}
defer f.Close() // 确保函数退出时文件被关闭
data, err := io.ReadAll(f)
return data, err
}
不管函数是正常返回还是因为错误返回，f.Close() 都会被执行。你不需要在每个 return 前面都写一遍关闭文件的代码。
2. 释放锁
var mu sync.Mutex
func safeIncrement(counter *int) {
mu.Lock()
defer mu.Unlock() // 确保锁被释放
*counter++
}
3. 记录函数执行时间
func timeTrack(start time.Time, name string) {
elapsed := time.Since(start)
fmt.Printf("%s 执行耗时: %v\n", name, elapsed)
}
func slowFunction() {
defer timeTrack(time.Now(), "slowFunction")
time.Sleep(2 * time.Second)
// 做一些耗时的操作...
}
defer 的参数求值时机
一个重要的细节：defer 语句中的参数在 defer 声明时就被求值了，而不是在 defer 执行时。
func main() {
i := 1
defer fmt.Println("defer 中的 i =", i)
i = 2
fmt.Println("main 中的 i =", i)
}
// 输出：
// main 中的 i = 2
// defer 中的 i = 1
i 的值在 defer 声明时就已经被确定为 1，后面修改 i 不会影响 defer 中已经捕获的值。
但如果你通过闭包或者指针来访问变量，defer 执行时会读取变量的最新值：
func main() {
i := 1
defer func() {
fmt.Println("defer 闭包中的 i =", i)
}()
i = 2
fmt.Println("main 中的 i =", i)
}
// 输出：
// main 中的 i = 2
// defer 闭包中的 i = 2
panic 与 recover 机制
Go 没有传统的 try-catch 异常机制，而是使用 panic 和 recover 来处理不可恢复的错误。
panic
panic 用于表示程序遇到了严重错误，无法继续执行。当 panic 发生时，程序会立即停止当前函数的执行，然后沿着调用栈向上回溯，执行每一层函数的 defer 语句，直到程序崩溃或者遇到 recover。
package main
import "fmt"
func mayPanic() {
panic("出错了！这是一个严重问题。")
}
func main() {
fmt.Println("程序开始")
mayPanic()
fmt.Println("这行不会执行")
}
// 输出：
// 程序开始
// panic: 出错了！这是一个严重问题。
recover
recover 用于捕获 panic，防止程序崩溃。它只能在 defer 函数中调用。如果当前 goroutine 没有发生 panic，recover 返回 nil。
package main
import "fmt"
func mayPanic() {
panic("出错了！这是一个严重问题。")
}
func safeCall() {
defer func() {
if r := recover(); r != nil {
fmt.Println("捕获到 panic:", r)
fmt.Println("程序恢复运行")
}
}()
mayPanic()
fmt.Println("这行不会执行")
}
func main() {
fmt.Println("程序开始")
safeCall()
fmt.Println("程序结束")
}
// 输出：
// 程序开始
// 捕获到 panic: 出错了！这是一个严重问题。
// 程序恢复运行
// 程序结束
panic/recover 的使用原则
panic 和 recover 不应该被滥用来替代正常的错误处理。它们的使用场景很有限：
适合使用 panic 的场景：
- 程序启动时的配置错误（如数据库连接不上）
- 程序员犯的错误（如数组越界访问，这通常是 bug）
- 不可恢复的内部状态损坏
不应该使用 panic 的场景：
- 用户输入错误（应该返回 error）
- 网络请求失败（应该返回 error）
- 文件不存在（应该返回 error）
Go 社区有一个著名的口号：不要 panic，要处理错误（Don’t panic, handle errors）。
panic 与 defer 的交互
panic 发生时会执行当前 goroutine 中所有已注册的 defer，这给了我们清理资源的机会：
package main
import "fmt"
func riskyOperation() {
defer fmt.Println("defer 1: 清理资源 A")
defer fmt.Println("defer 2: 清理资源 B")
defer fmt.Println("defer 3: 清理资源 C")
panic("发生严重错误！")
// 这行不会执行
defer fmt.Println("defer 4: 这行不会执行")
}
func main() {
defer func() {
if r := recover(); r != nil {
fmt.Println("恢复运行，panic 原因:", r)
}
}()
riskyOperation()
}
// 输出：
// defer 3: 清理资源 C
// defer 2: 清理资源 B
// defer 1: 清理资源 A
// 恢复运行，panic 原因: 发生严重错误！
注意 defer 仍然按照 LIFO 顺序执行，即使是因为 panic。
进阶函数概念
函数值
在 Go 中，函数值（function value）不仅仅是代码的指针，它还包含了一个指向闭包环境的指针。这意味着每个函数值都是唯一的，即使它们来自同一个函数定义。
package main
import "fmt"
func makeMultiplier(factor int) func(int) int {
return func(x int) int {
return x * factor
}
}
func main() {
double := makeMultiplier(2)
triple := makeMultiplier(3)
fmt.Println(double(5)) // 10
fmt.Println(triple(5)) // 15
// 每个函数值都是独立的
fmt.Printf("double 指针: %p\n", double)
fmt.Printf("triple 指针: %p\n", triple)
}
递归调用
递归是函数调用自身的技巧。Go 支持递归，但要注意递归深度过大可能导致栈溢出（尽管 Go 的栈是动态增长的，能处理相当大的深度）。
package main
import "fmt"
// 计算阶乘：n! = n * (n-1) * ... * 1
func factorial(n int) int {
if n <= 1 {
return 1
}
return n * factorial(n-1)
}
// 斐波那契数列：F(n) = F(n-1) + F(n-2)
func fibonacci(n int) int {
if n <= 1 {
return n
}
return fibonacci(n-1) + fibonacci(n-2)
}
// 尾递归优化版本（Go 不自动优化，但可以手动写）
func factorialTail(n, acc int) int {
if n <= 1 {
return acc
}
return factorialTail(n-1, n*acc)
}
func main() {
fmt.Println("5! =", factorial(5)) // 120
fmt.Println("fib(10) =", fibonacci(10)) // 55
fmt.Println("5! (尾递归) =", factorialTail(5, 1)) // 120
}
注意 Go 目前不支持尾递归优化，所以尾递归版本和普通递归版本的性能差别不大。对于大数计算，迭代版本通常比递归版本更高效。
函数式编程模式
虽然 Go 不是纯函数式编程语言，但你可以利用一等函数和闭包来实现很多函数式编程模式：
package main
import "fmt"
// Map: 对切片每个元素应用函数
func Map[T any, R any](input []T, fn func(T) R) []R {
result := make([]R, len(input))
for i, v := range input {
result[i] = fn(v)
}
return result
}
// Filter: 根据条件过滤切片元素
func Filter[T any](input []T, fn func(T) bool) []T {
result := make([]T, 0, len(input))
for _, v := range input {
if fn(v) {
result = append(result, v)
}
}
return result
}
// Reduce: 将切片归约为单一值
func Reduce[T any, R any](input []T, initial R, fn func(R, T) R) R {
result := initial
for _, v := range input {
result = fn(result, v)
}
return result
}
func main() {
numbers := []int{1, 2, 3, 4, 5}
// 每个数乘以 2
doubled := Map(numbers, func(n int) int { return n * 2 })
fmt.Println("乘以 2:", doubled) // [2 4 6 8 10]
// 过滤出偶数
evens := Filter(numbers, func(n int) bool { return n%2 == 0 })
fmt.Println("偶数:", evens) // [2 4]
// 求和
sum := Reduce(numbers, 0, func(acc, n int) int { return acc + n })
fmt.Println("总和:", sum) // 15
}
注意：上面的 Map/Filter/Reduce 示例使用了泛型（Go 1.18+ 特性）。如果你的项目使用更早的 Go 版本，需要为每种类型分别实现或者使用 interface{}。
工程实战案例
中间件模式实现
中间件是一种常见的设计模式，在 Web 开发中特别流行。每个中间件负责一个横切关注点（cross-cutting concern），如日志、认证、限流等。
package main
import (
"fmt"
"time"
)
// Handler 是处理函数的类型
type Handler func(string) string
// Middleware 是中间件的类型
type Middleware func(Handler) Handler
// LoggingMiddleware 记录请求日志
func LoggingMiddleware(next Handler) Handler {
return func(req string) string {
start := time.Now()
result := next(req)
fmt.Printf("[日志] 请求: %s, 耗时: %v\n", req, time.Since(start))
return result
}
}
// AuthMiddleware 验证请求权限
func AuthMiddleware(next Handler) Handler {
return func(req string) string {
if req == "恶意请求" {
return "错误: 未授权"
}
fmt.Println("[认证] 验证通过")
return next(req)
}
}
// TimingMiddleware 统计执行时间
func TimingMiddleware(next Handler) Handler {
return func(req string) string {
fmt.Println("[计时] 开始")
result := next(req)
fmt.Println("[计时] 结束")
return result
}
}
// ApplyMiddlewares 链式应用多个中间件
func ApplyMiddlewares(handler Handler, middlewares ...Middleware) Handler {
for i := len(middlewares) - 1; i >= 0; i-- {
handler = middlewares[i](handler)
}
return handler
}
func main() {
// 原始处理函数
businessHandler := func(req string) string {
fmt.Printf("处理业务请求: %s\n", req)
return "成功: " + req
}
// 应用中间件
handler := ApplyMiddlewares(
businessHandler,
LoggingMiddleware,
AuthMiddleware,
TimingMiddleware,
)
result := handler("获取用户列表")
fmt.Println(result)
}
这个模式的优雅之处在于：每个中间件只关注自己的职责，业务逻辑和横切关注点完全分离。而且你可以根据需要随意组合和排序中间件。
AOP 思想实现
面向切面编程（AOP）的中间件版本：
package main
import (
"fmt"
"reflect"
"runtime"
)
// around 是一个通用的 AOP 包装器
func around(fn interface{}, before func(), after func()) interface{} {
return fn
}
// Trace 打印函数调用信息
func Trace(fn func()) func() {
return func() {
fnName := runtime.FuncForPC(reflect.ValueOf(fn).Pointer()).Name()
fmt.Printf("[Trace] 进入 %s\n", fnName)
fn()
fmt.Printf("[Trace] 离开 %s\n", fnName)
}
}
func main() {
doWork := func() {
fmt.Println("正在工作...")
}
tracedWork := Trace(doWork)
tracedWork()
}
函数调用性能分析
在性能敏感的场景下，了解不同调用方式的开销很重要。
| 调用方式 | 开销 | 特点 | 适用场景 |
|---|---|---|---|
| 直接调用 | 最低 | 编译器内联优化 | 所有常规场景 |
| 函数值调用 | 较低 | 间接调用，无法内联 | 回调、策略模式 |
| 闭包调用 | 中等 | 捕获变量，有内存分配 | 状态保持、工厂函数 |
| 方法值调用 | 中等 | receiver 作为第一个参数 | 面向对象风格 |
| 接口调用 | 较高 | 动态分派 | 多态、解耦 |
| 反射调用 | 最高 | 运行时解析 | 通用框架 |
性能对比示例
package main
import (
"fmt"
"testing"
)
type Calculator struct{}
func (c Calculator) Add(a, b int) int { return a + b }
func BenchmarkDirect(b *testing.B) {
for i := 0; i < b.N; i++ {
_ = add(1, 2)
}
}
func BenchmarkFuncValue(b *testing.B) {
f := add
for i := 0; i < b.N; i++ {
_ = f(1, 2)
}
}
func BenchmarkClosure(b *testing.B) {
f := func(a, b int) int { return a + b }
for i := 0; i < b.N; i++ {
_ = f(1, 2)
}
}
func BenchmarkMethodValue(b *testing.B) {
c := Calculator{}
for i := 0; i < b.N; i++ {
_ = c.Add(1, 2)
}
}
func BenchmarkInterface(b *testing.B) {
type Adder interface{ Add(int, int) int }
var a Adder = Calculator{}
for i := 0; i < b.N; i++ {
_ = a.Add(1, 2)
}
}
func add(a, b int) int { return a + b }
func main() {
fmt.Println("运行 go test -bench=. 查看性能对比结果")
}
一般来说，Go 编译器非常聪明，会尽可能地进行内联优化。在大多数时候，你不需要担心函数调用的开销，优先考虑代码的可读性和可维护性。
init 函数
Go 有一个特殊的函数叫做 init()。它在包被导入时自动执行，不需要你手动调用。每个包可以有多个 init 函数，它们会按照文件名的字母顺序执行。
package main
import "fmt"
func init() {
fmt.Println("init 函数执行了")
}
func main() {
fmt.Println("main 函数执行了")
}
// 输出：
// init 函数执行了
// main 函数执行了
init 函数通常用于包的初始化工作，比如设置默认配置、注册驱动等。
init 函数的执行顺序
当一个包被导入时，执行顺序是：
- 先执行导入包的 init 函数
- 然后执行当前包的 init 函数
- 最后执行 main 函数
package main
import "fmt"
func init() {
fmt.Println("main 包的 init")
}
func main() {
fmt.Println("main 函数")
}
// 如果导入了其他包，会先执行那些包的 init
// 输出顺序：
// 包 A 的 init
// 包 B 的 init
// main 包的 init
// main 函数
最佳实践
错误处理最佳实践
- 错误只在需要时创建：不要为正常流程创建错误
- 错误信息要包含有用的上下文：使用 fmt.Errorf 包装错误并添加上下文
- 不要忽略错误：即使是你认为不可能出错的调用
- 尽早返回：减少嵌套层级
// 好的写法：尽早返回
func goodPractice() error {
f, err := os.Open("file.txt")
if err != nil {
return fmt.Errorf("打开文件失败: %w", err)
}
defer f.Close()
data, err := io.ReadAll(f)
if err != nil {
return fmt.Errorf("读取文件失败: %w", err)
}
// 处理数据...
_ = data
return nil
}
函数设计原则
- 单一职责：每个函数只做一件事
- 控制函数长度：一般不超过 50 行，复杂的逻辑拆分为子函数
- 参数数量不宜过多：超过 4 个参数考虑使用配置结构体
- 命名要清晰：函数名应该描述它做什么，而不是怎么做
- **优先返回值而不是修改参数
常见问题 FAQ
Q1：defer 在什么场景下最实用？
A：defer 最适合资源清理场景：关闭文件、释放锁、关闭数据库连接、记录函数执行时间等。它的核心价值是确保资源被释放，无论函数以何种方式返回（正常返回、错误返回、panic）。这让代码更简洁，也不容易遗漏清理逻辑。
Q2：闭包捕获变量是值捕获还是引用捕获？
A：闭包在 Go 中是通过引用捕获变量的。闭包引用的外部变量不会被销毁，而是被提升到堆上，闭包和外部代码共享同一个变量。这意味着闭包内外对同一变量的修改会相互影响。如果你需要值捕获，可以在闭包内创建局部副本。
for i := 0; i < 3; i++ {
i := i // 创建局部副本，避免所有闭包共享同一个 i
defer func() {
fmt.Println(i)
}()
}
Q3：panic 和 error 有什么区别？
A：error 用于可预期的、可以通过代码处理的错误（如文件不存在、网络超时）。panic 用于不可恢复的错误（如程序 bug、内存耗尽）。一个经验法则：如果错误可以由调用者处理，返回 error；如果错误表示程序本身有问题，用 panic。
Q4：recover 能在任何地方使用吗？
A：recover 只能在 defer 函数中生效。在普通函数中调用 recover 会返回 nil，没有任何效果。这是因为 recover 的设计目的是在资源清理的同时捕获 panic，而不是作为一种常规的流程控制手段。
Q5：函数返回多个值时，性能会受影响吗？
A：不会。Go 的多返回值是通过在栈上分配额外的空间来实现的，开销极小。实际上，Go 的多返回值比 C 语言用指针参数模拟多返回值的性能更好，因为 Go 可以更好地利用寄存器。
Q6：匿名函数和命名函数有什么性能差异？
A：在大多数场景下，性能差异可以忽略不计。匿名函数的主要开销是闭包捕获变量时可能导致变量逃逸到堆上（引发 GC 压力）。如果你发现性能瓶颈，可以用命名函数替代，或使用逃逸分析工具检查。
Q7：defer 在循环中使用要注意什么？
A：在循环中使用 defer 要谨慎，因为 defer 是在函数返回时才执行的，不是在循环迭代结束时执行。如果在循环中注册了 1000 个 defer，它们会在函数返回时全部执行，可能导致性能问题。
// 不好的做法：累积大量 defer
func bad() {
for i := 0; i < 1000; i++ {
f, _ := os.Open(fmt.Sprintf("file%d.txt", i))
defer f.Close() // 1000 个 defer 会累积！
}
}
// 好的做法：用函数封装
func good() {
for i := 0; i < 1000; i++ {
func() {
f, _ := os.Open(fmt.Sprintf("file%d.txt", i))
defer f.Close()
// 处理文件...
}()
}
}
Q8：什么时候使用命名返回值？
A：命名返回值适合以下场景：
- 函数逻辑简单，返回值的含义很明确（如 (x, y int)）
- 函数有多个返回值且裸返回能提高可读性
- 文档目的：在函数签名中就说明返回值的含义
不适合在长函数中使用，因为裸返回会让读者不清楚具体返回了什么值。
Q9：Go 有函数重载吗？
A：Go 不支持函数重载（即同名函数不同参数列表）。这是 Go 设计者有意为之的简化——他们认为重载虽然方便，但会让代码更难理解和维护。如果你需要类似的功能，可以使用可变参数、接口参数或不同的函数名。
// 不支持重载：
// func Add(a, b int) int
// func Add(a, b float64) float64 // ❌ 编译错误
// 替代方案 1：用不同的函数名
func AddInt(a, b int) int
func AddFloat(a, b float64) float64
// 替代方案 2：用泛型（Go 1.18+）
func Add[T int | float64](a, b T) T
Q10：如何让 defer 也参与 panic 恢复？
A：defer 函数中如果有 recover，可以捕获同一个 goroutine 中的 panic。这是 Go 错误恢复的核心模式。但要注意：recover 只能捕获当前 goroutine 的 panic，跨 goroutine 的 panic 是无法被捕获的。
延伸阅读
如果你想更深入地学习 Go 语言的函数系统，以下是一些推荐的资源：
- Go 语言规范 - 函数：https://golang.org/ref/spec#Function_declarations
- Effective Go - 函数：https://golang.org/doc/effective_go.html#functions
- Go by Example - Functions：https://gobyexample.com/functions
- Go 博客 - Defer, Panic, and Recover：https://go.dev/blog/defer-panic-and-recover
- Go 中间件模式：https://drstearns.github.io/tutorials/gomiddleware/
- Go 性能优化：https://dave.cheney.net/high-performance-go-workshop/gopherchina-2019.html
小结
今天我们全面学习了 Go 语言的函数系统：
- 基本定义：func 关键字、参数列表、返回类型
- 多返回值：Go 函数可以返回多个值，常用来同时返回结果和错误
- 命名返回值：可以给返回值命名，支持裸返回
- 可变参数：用 … 声明可以接收任意数量参数的函数
- 函数作为值：函数是一等公民，可以作为参数传递和赋值
- 匿名函数：没有名字的函数，可以立即执行或赋值给变量
- 闭包：匿名函数可以捕获外部作用域的变量
- defer：延迟执行，常用于资源清理（关闭文件、释放锁等）
- panic/recover：处理不可恢复的错误，类似于异常机制
- 递归：函数调用自身，注意尾递归不被优化
- 函数式编程：利用 map/filter/reduce 等模式处理数据
- 中间件模式：实现 AOP 和解耦的利器
- init 函数：包初始化时自动执行
Go 的函数设计追求实用。多返回值解决了错误处理的难题，defer 简化了资源管理，闭包提供了灵活的代码组织方式，panic/recover 提供了最后的防线。这些特性组合在一起，让你能写出既简洁又可靠的代码。
练习时间
- 最大公约数：写一个函数，用辗转相除法计算两个数的最大公约数
- 多返回值：写一个函数，接收一个整数切片，返回最大值、最小值和平均值
- 闭包计数器：用闭包实现一个斐波那契生成器，每次调用返回下一个斐波那契数
- defer 实验：写一个函数，里面放 3 个 defer 语句，观察它们的执行顺序
- 函数组合：写一个 compose 函数，它接收两个函数 f 和 g，返回一个新函数 h，使得 h(x) = f(g(x))
- panic/recover：写一个函数，在其中触发 panic，然后在调用者中用 recover 捕获并恢复
- 中间件链：实现一个日志中间件和鉴权中间件，然后用链式调用的方式组合它们
- 递归转迭代：写一个递归版本的阶乘函数，然后改写成迭代版本，比较两者性能
下一篇预告
下一篇文章，我们将学习 Go 语言中数组和切片。切片是 Go 语言中最常用的数据结构之一，但也是最容易让人困惑的。我们会深入探讨：
- 数组和切片的区别
- 切片的底层原理
- make 和 append 的工作方式
- 切片的常见陷阱和最佳实践
我们下篇见！
参考资料：
继续阅读
探索更多技术文章
浏览归档，发现更多关于系统设计、工具链和工程实践的内容。