Go中的闭包函数Closure示例详解

目录

• 前言
• 1. 通俗定义：自带“背包”的函数
• 2. 代码演示：最经典的计数器
• 3. 底层原理：变量去哪了？（CS 专业向）
• 4. 闭包在实战中的三大用途
• A. 封装状态（像简化的类）
• B. 延迟执行 / 回调 (Callback)
• C. 中间件 / 装饰器 (Middleware / Decorator)
• 总结
• 情况一：调用两次“工厂函数” (你的 main 函数里的情况)
• 情况二：调用同一个“闭包实例”多次
• 用那个计数器的例子看最清楚
• 总结你的 makeHandler 代码

“闭包”（Closure）是编程中一个非常重要、但初学者容易晕的概念。它在函数式编程（Functional Programming）中无处不在，Go 语言对它的支持非常强大。

简单来说，闭包就是：一个函数和它周围环境的绑定。

为了让你彻底理解，我们从三个层面来拆解：通俗定义、代码演示、以及底层原理。

通常情况下，一个函数执行完，它内部定义的变量就会被销毁（从内存栈中弹出）。

但是闭包不一样。闭包是一个特殊的函数，它被创建的时候，会偷偷把当时它能看到的变量抓取过来，装进自己的“背包”里带走。

公式：

闭包 = 函数代码 + 捕获的外部变量

哪怕创造它的那个外部函数已经执行结束了，闭包依然能通过“背包”访问和修改那些变量。

这是理解闭包的“Hello World”例子。

Go

package main

import "fmt"

// seq 此时是一个“工厂”，它返回一个函数
// 这个返回的函数返回 int
func seq() func() int {
    i := 0 // 这是一个局部变量，按理说 seq 执行完它就该销毁了
    
    // 返回一个匿名函数
    return func() int {
        i++ // 这个匿名函数引用了外部的 i
        return i
    }
}

func main() {
    // 1. 创建第一个闭包实例 nextNum
    // 此时 seq() 执行结束，但变量 i 被 nextNum 的背包抓走了
    nextNum := seq()

    fmt.Println(nextNum()) // 输出 1
    fmt.Println(nextNum()) // 输出 2
    fmt.Println(nextNum()) // 输出 3 (i 的状态被保留了！)

    // 2. 创建第二个闭包实例 nextNum2
    // 它会有自己全新的 i，和上面那个互不干扰
    nextNum2 := seq()
    fmt.Println(nextNum2()) // 输出 1
}

为什么叫闭包？ 注意看 i。它定义在 seq 里，但在 main 里通过 nextNum() 依然能一直修改它。nextNum 这个函数把 i “封闭”在自己的作用域里了，这就叫闭包。

作为一个计算机专业的学生，你可能会问：“栈上的局部变量不是函数返回就销毁了吗？为什么 i 还能活下来？”

这里涉及到了 Go 编译器的逃逸分析 (Escape Analysis)。

• 正常情况：函数内部的变量分配在栈 (Stack) 上，函数结束，栈帧弹出，数据销毁。

• 闭包情况：编译器扫描代码，发现变量 i 被内部的匿名函数引用了，而且这个匿名函数被返回到了外部。

• 逃逸：编译器判定 i 不能死在栈上，于是把它分配到了堆 (Heap) 上。

• 引用：返回的闭包函数（nextNum）内部持有一个指针，指向堆上的这个 i。

所以，当你调用 makeHandler(viewHandler) 时，那层“中间件”之所以能记住 viewHandler 是谁，就是因为 fn 这个变量逃逸到了堆上，被返回的那个匿名函数死死抓在手里。

回到你的 HTTP 题目，以及以后的开发中，闭包主要有这就三种用法：

不需要专门写一个 struct 或者 class 来存状态，直接用闭包。上面的计数器就是例子。

当你把一个函数 A 传给另一个函数 B，B 在未来某个时间点调用 A，A 还能记得当初传给它的数据。

这就是你那段代码的本质。 你想给原本的函数 viewHandler 加一层“安检”。

• 输入：一个旧函数。

• 输出：一个新函数（新函数 = 安检逻辑 + 旧函数）。

Go

// 这就是一个典型的装饰器模式（Decorator Pattern）
func makeHandler(fn ...) http.HandlerFunc {
    return func(...) {
        // 1. 前置逻辑 (Pre-processing)
        // ... 验证 title ...
        
        // 2. 调用原函数 (Original logic)
        fn(...) 
        
        // 3. 后置逻辑 (Post-processing) - 可选
    }
}

• 闭包就是能记住它出生环境的函数。

• 在 Go 里，闭包让局部变量逃逸到堆上，从而延长了变量的生命周期。

• 在很多场景下（比如你的 Web 路由处理），用闭包比定义一个 Interface 或者 Struct 更轻量、更优雅。

看一段代码：

package main

import "fmt"

func adder() func(int) int {
	sum := 0
	return func(x int) int {
		sum += x
		return sum
	}
}

func main() {
	pos, neg := adder(), adder()
	for i := 0; i < 10; i++ {
		fmt.Println(
			pos(i),
			neg(-2*i),
		)
	}
}

输出结果：

0 0
1 -2
3 -6
6 -12
10 -20
15 -30

每次调用 makeHandler（工厂），都会产生一个新的、独立的闭包环境。它们互不干扰，不引用同一个变量。

为了让你彻底明白，我们要分两种情况来看：

这是你在 main 函数里写的代码逻辑：

Go

// 第 1 次调用 makeHandler
// 产生了一个闭包 A，它的背包里装的是 viewHandler
h1 := makeHandler(viewHandler) 

// 第 2 次调用 makeHandler
// 产生了一个闭包 B，它的背包里装的是 editHandler
h2 := makeHandler(editHandler) 

结论： 它们不引用同一个变量。

原理： 每次你调用 makeHandler 时，Go 都会在内存中开辟一个新的栈帧 (Stack Frame)。

• 第一次调用时，参数 fn 是 viewHandler。这个 fn 也就是闭包 A “背包”里的东西。

• 第二次调用时，参数 fn 是 editHandler。这个 fn 是闭包 B “背包”里的东西。

虽然变量名都叫 fn，但它们在内存里是两块完全不同的地址。就好比你去了两次肯德基，第一次买了汉堡，第二次买了薯条。虽然都装在“打包袋”里，但这是两个不同的袋子，装的东西也不一样。

这是当服务器运行起来，多个用户访问同一个 URL 时的情况：

Go

// 假设这是 main 函数里注册好的那个 handler
viewHandlerWrapper := makeHandler(viewHandler)

// 用户甲访问 /view/1
viewHandlerWrapper(w1, r1) 

// 用户乙访问 /view/2
viewHandlerWrapper(w2, r2)

结论： 它们引用的是同一个外部变量。

原理： 因为 viewHandlerWrapper 是同一个闭包实例。 在这个例子里，它们引用的那个“外部变量”就是被捕获的 fn (也就是 viewHandler)。 无论用户调用多少次 viewHandlerWrapper，它都会去自己的背包里找那个 fn。这也是正确的，因为我们希望大家用的处理逻辑是一样的。

回到刚才的计数器 seq，这能最直观地展示“变量隔离”：

Go

func seq() func() int {
    i := 0 // 这就是那个“外部变量”
    return func() int {
        i++
        return i
    }
}

func main() {
    // 【工厂调用两次】：创造了两个独立的世界
    counterA := seq() 
    counterB := seq()

    // counterA 的背包里有一个 i (地址 0x1111)
    // counterB 的背包里有一个 i (地址 0x2222)

    fmt.Println(counterA()) // 输出 1 (修改的是 0x1111)
    fmt.Println(counterA()) // 输出 2 (修改的是 0x1111)

    // 关键点来了：
    fmt.Println(counterB()) // 输出 1 (修改的是 0x2222)
    // 发现了吗？counterB 从头开始计数，完全没受 counterA 影响！
}

在你的代码中：

Go

func makeHandler(fn func(...)) http.HandlerFunc {
    return func(w, r) {
        // ...
        fn(w, r, title) // 这里的 fn 是被捕获的
    }
}

• makeHandler(viewHandler) 创建了一个闭包，它独占 viewHandler。

• makeHandler(editHandler) 创建了另一个闭包，它独占 editHandler。

它们互不干扰，绝对安全。 这也是为什么闭包在 Go 的并发编程和中间件设计中如此好用的原因——它天然地实现了状态的隔离。

到此这篇关于Go中闭包函数Closure的文章就介绍到这了,更多相关Go闭包函数Closure内容请搜索风君子博客以前的文章或继续浏览下面的相关文章希望大家以后多多支持风君子博客！

您可能感兴趣的文章:

• Golang中的闭包（Closures）详解
• 一文详解go闭包(Closure)使用教程