func 值在运行时是一个指针加一个环境槽，闭包捕获的是变量而不是值——变量活多久，闭包就抓着它多久。工程上的坑几乎都在这个交叉处：循环里启动 goroutine 抓循环变量、defer 在循环里堆积、闭包顺手把整个大结构体带进堆。这篇按一等值、返回值、defer、闭包、选项模式逐层拆。

---

1. 函数是一等值

package main

import "fmt"

type IntOp func(int, int) int

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

func apply(f IntOp, a, b int) int { return f(a, b) }

func main() {
	var f IntOp = add
	fmt.Println(apply(f, 2, 3))     // 5
	fmt.Println(apply(mul, 2, 3))   // 6

	fns := []IntOp{add, mul}
	for _, fn := range fns {
		fmt.Println(fn(4, 5))
	}
}

用法	写法	场景
赋给变量	f := add	动态选择实现
作为参数	apply(add, 1, 2)	策略注入
作为返回值	return add	工厂函数
存入结构体字段	Handler func(...)	回调、路由表
存入 map	map[string]func()	命令分派
自定义函数类型	type IntOp func(...)	可为其定义方法

函数值只能与 nil 比较，不能互相比较，也不能做 map 的 key。

1.1 为函数类型定义方法

type Handler func(string) string
type Middleware func(Handler) Handler

func (m Middleware) Then(next Handler) Handler { return m(next) }

func main() {
	var mw Middleware = func(next Handler) Handler {
		return func(s string) string { return "[" + next(s) + "]" }
	}
	h := mw.Then(func(s string) string { return s })
	fmt.Println(h("x"))   // [x]
}

给函数类型加方法能让中间件链式组合，net/http 生态里很常见。

---

2. 多返回值与命名返回值

func divmod(a, b int) (int, int) { return a / b, a % b }

func parse(s string) (n int, err error) {
	if s == "" {
		err = fmt.Errorf("empty input")
		return              // 裸 return，返回当前命名值
	}
	return len(s), nil
}

命名返回值不是语法糖，它真实创建了两个变量，并在函数入口初始化为零值。这带来两个后果：

特性	含义	风险
入口即零值	n、err 一开始就是 0、nil	忘赋值会静默返回零值
defer 可修改	defer 改命名返回值会改变最终返回	隐蔽，易误判
裸 return	返回当前命名值	长函数可读性差

defer 修改命名返回值的经典用法：

func count() (n int) {
	defer func() { n++ }()
	return 5
}   // count() 返回 6

如果返回值不命名（func count() int），defer 里的 n++ 改的是局部副本，返回值不受影响。这个差异在写"panic 转 error"时非常关键，见 X06。

---

3. 可变参数与切片展开

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

sum(1, 2, 3)           // 6
s := []int{4, 5, 6}
sum(s...)              // 15，切片展开
sum()                  // 0，零个参数合法

nums 在函数内是 []int，nil 时 range 也安全。展开用 s...，展开不复制——被调方拿到同一个底层数组。

规则	说明
只能有一个可变参数	且必须在参数列表末尾
调用时可传零个	内部得到 nil 切片
展开必须是同类型切片	[]int 只能展开成 ...int
展开不复制	被调方修改元素会影响调用方
append(dst, src...)	最常见的展开用法

常见误用是 sum(s...) 之后在 sum 内部 append(nums, x)：容量够时会写到 s 的底层数组里。

---

4. 闭包捕获的是变量

func counter() func() int {
	n := 0
	return func() int {
		n++          // 捕获的是变量 n，不是值 0
		return n
	}
}

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

n 本该随 counter 返回而消失，但闭包持有它，编译器把 n 分配到堆上。这就是"闭包延长变量生命周期"。

4.1 循环变量捕获：Go 1.22 的分界

// ≤1.21：三次可能都输出 3；≥1.22：必是 0 1 2（顺序不定）
for i := 0; i < 3; i++ {
	go func() { fmt.Println(i) }()
}

版本	for 循环变量	行为
≤ 1.21	整个循环共用一个变量	闭包/goroutine 常见捕获坑，需 i := i
≥ 1.22	每轮迭代新建变量	坑消失，i := i 变冗余

go.mod 里声明的 go 版本决定语义：go 1.22 及以上才启用新规则。升级 go 指令前要审查所有依赖循环闭包的代码——旧代码在 1.22 下行为会变，虽然通常是变对了，但依赖"共享变量"的写法会失效。

// 旧版本的正确写法
for i := 0; i < 3; i++ {
	i := i
	go func() { fmt.Println(i) }()
}

range 的 value 变量同理：for _, v := range s 里 &v 在旧版本永远得到同一地址。

4.2 闭包意外捕获大对象

func handler(big []byte) func() int {
	return func() int { return len(big) }   // 整个 big 被闭包持有
}

即使只用到 len(big)，整个底层数组也无法回收。修法是先把需要的值取出来：

func handler(big []byte) func() int {
	n := len(big)
	return func() int { return n }          // 只捕获一个 int
}

捕获内容	内存影响	处理
局部 int/string	小，随闭包进堆	无
大 slice / map	整个容器被持有	先取出标量再捕获
结构体指针	整个对象被持有	只捕获需要的字段副本

---

5. defer 的三条规则

defer 的语义可以压缩成三条，记死就够用。

规则	含义	例子
参数立即求值	defer 语句的参数在注册时求值，不是执行时	defer f(x) 用的是当前 x
执行顺序 LIFO	后注册先执行	三个 defer 逆序输出
可改命名返回值	执行时机在 return 赋值之后	见第 2 节

x := 1
defer fmt.Println("deferred x =", x)   // 参数此时求值：捕获 1
x = 2
fmt.Println("body x =", x)             // 2
// 返回后输出：deferred x = 1

想延迟读值，用闭包包一层：defer func() { fmt.Println(x) }()。

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

5.1 defer 在循环里堆积

// 差：一万次迭代积一万个 defer，全部在函数返回时执行
for _, p := range paths {
	f, err := os.Open(p)
	if err != nil {
		return err
	}
	defer f.Close()
}

// 好：抽成函数，每轮结束即关闭
for _, p := range paths {
	if err := readOne(p); err != nil {
		return err
	}
}

func readOne(p string) error {
	f, err := os.Open(p)
	if err != nil {
		return err
	}
	defer f.Close()
	_, err = io.Copy(io.Discard, f)
	return err
}

堆积的代价是双份的：文件描述符在函数返回前一直不释放（可能撞 ulimit），defer 记录本身也占内存。Go 1.14 起 defer 有了开放编码优化，单次开销很低（典型场景下接近直接调用，按当前版本核对），但堆积语义上的问题与性能无关。

---

6. 选项模式：用闭包做配置

Go 没有命名参数、没有构造函数重载，配置组合的标准解法是函数选项。

type Server struct {
	Addr    string
	Timeout time.Duration
	MaxConn int
}

type Option func(*Server)

func WithAddr(a string) Option   { return func(s *Server) { s.Addr = a } }
func WithTimeout(d time.Duration) Option { return func(s *Server) { s.Timeout = d } }
func WithMaxConn(n int) Option   { return func(s *Server) { s.MaxConn = n } }

func NewServer(opts ...Option) *Server {
	s := &Server{Addr: ":8080", Timeout: 30 * time.Second, MaxConn: 100}
	for _, o := range opts {
		o(s)
	}
	return s
}

s := NewServer(WithAddr(":9090"), WithMaxConn(500))

方案	优点	缺点
函数选项	可扩展、不改签名	参数多时调用处较长
配置结构体	直观、易序列化	难区分"未设置"与"零值"
Builder	链式易读	样板代码多

选项模式的隐藏成本：每个 Option 都持有 *Server，选项函数若被长期保存，就延长了 Server 的生命周期。所以选项应当即用即弃，不要存进全局。

---

7. 函数与方法的区别

维度	函数	方法
是否有接收者	无	有（值或指针）
能否为外部类型添加	不适用	只能为本包内定义的类型添加
能否赋给变量	能，f := add	能，f := t.M（绑定接收者，形成闭包）
能否满足接口	不行（需具名类型）	能
调用开销	直接	经接口时动态派发

t.M 取方法值时会立即复制接收者或绑定指针：

type T struct{ N int }
func (t T) Get() int { return t.N }

t := T{N: 1}
f := t.Get      // 绑定当前副本
t.N = 99
fmt.Println(f())   // 1，不是 99

方法表达式 T.Get 则不同，它把接收者变成第一个参数：T.Get(t)。

---

8. 排错：五个高频坑

现象	原因	处理
循环里 goroutine 全打印同一个值	旧版本共享循环变量	升级 go 指令至 1.22+，或 i := i
defer 打印的是旧值	参数注册时已求值	用闭包延迟读：defer func(){...}()
文件句柄耗尽	循环内 defer 堆积	抽成小函数
内存不降，闭包是唯一线索	闭包捕获大对象	先取标量再捕获
defer 里改返回值无效	返回值未命名	命名返回值，或用 *error 输出参数

---

9. 边界：这些情况本就该换写法

场景	用闭包	更合适的选择
需要可比较、可序列化的回调	闭包不可比较	具名函数 + 注册表
需要跨 goroutine 共享状态	闭包捕获 + 锁	显式结构体 + sync 类型
需要撤销的副作用	闭包持有资源	显式 Close() 接口
深层嵌套回调	闭包套闭包	拆成具名函数，更易测
需要反射调用	reflect.ValueOf(f)	接口 + 方法集

一句话：闭包适合"短生命周期的一次性逻辑"，一旦捕获的资源需显式释放、或逻辑要单测，就该落成具名函数。

---

10. 自测

1. 命名返回值和普通返回值在 defer 修改时行为差在哪？
2. for i := 0; i < 3; i++ { go func(){ fmt.Println(i) }() } 在 1.21 与 1.22 下输出有何不同？
3. defer fmt.Println(x) 与 defer func(){ fmt.Println(x) }() 打印的值为什么不同？
4. 循环里 defer f.Close() 有两个层面的问题，分别是什么？
5. 函数选项模式用什么机制实现"默认值 + 部分覆盖"？
6. f := t.Get 与 T.Get 的区别是什么？各自何时绑定接收者？