闭包的知识

🕗 发布于 2024-11-15 01:02 golang go 后端

1. 什么是闭包

在 Go 语言中，闭包（closure）是指一个函数与其外部环境变量的绑定，可以在函数外部依然访问并使用该函数的变量。闭包能够捕获并“记住”定义它时的环境，因此函数内部的变量即使在函数执行结束后依然可以被访问和操作。

闭包的基本特性

闭包是一种特殊的匿名函数，它会“捕获”或“引用”外部的变量环境，包含在其作用范围内的局部变量即使在函数返回后依然存在。在 Go 中，函数可以作为一种特殊的类型，因此可以返回函数作为闭包使用。

示例：闭包的基本使用

以下是一个简单的闭包示例，展示如何捕获并保持外部变量的状态。

package main

import "fmt"

// 生成闭包函数的工厂函数
func incrementer() func() int {
    // 局部变量 x，将在闭包中使用
    x := 0
    // 返回一个闭包函数
    return func() int {
        x++ // 每次调用时增加 x 的值
        return x
    }
}

func main() {
    inc := incrementer() // 获取一个闭包函数
    fmt.Println(inc())   // 输出：1
    fmt.Println(inc())   // 输出：2
    fmt.Println(inc())   // 输出：3
}

解释

incrementer 函数返回一个匿名函数。这个匿名函数捕获了 x 变量的引用。
每次调用 inc()，闭包都会增加 x 的值并返回该值，即使 incrementer 函数已经返回，x 的值依然保存在闭包中。
这样，我们通过闭包可以“记住”之前的状态。

闭包的应用场景

闭包在 Go 中主要用于以下场景：
1.计数器：像上例那样累积或递增变量值。
2.工厂模式：通过闭包构造特定的函数。
3.数据封装：通过闭包将某些数据封装在闭包内，外部无法直接访问，只能通过闭包的方式进行操作。

示例：闭包与局部环境

闭包可以捕获多种类型的变量，包括指针和其他函数。来看一个更加复杂的例子：

package main

import "fmt"

func multiplier(factor int) func(int) int {
    return func(x int) int {
        return x * factor
    }
}

func main() {
    double := multiplier(2)   // 创建一个“加倍”闭包
    triple := multiplier(3)   // 创建一个“三倍”闭包

    fmt.Println(double(5))    // 输出：10
    fmt.Println(triple(5))    // 输出：15
}

解释

multiplier 返回一个闭包函数，该闭包使用了 factor 变量。我们可以使用不同的 factor 来生成不同的闭包，比如 double（加倍）和 triple（三倍）。
闭包内的 factor 是在创建时被捕获并“锁定”的，因此 double 和 triple 都能记住它们创建时各自的倍数。

总结

闭包是带有环境变量引用的函数，可以保存和使用创建时的上下文数据。这种特性使得闭包在需要记住函数状态、创建自定义函数工厂、计数器等场景中非常有用。

2. 使用场景(1)

以下是分别展示闭包如何用于记住函数状态、创建自定义函数工厂、以及实现计数器的三个例子。

1. 记住函数状态

闭包可以记住函数执行时的状态，即使在函数执行结束后，这些状态依然存在。以下是一个例子，演示如何使用闭包在函数中保持状态。

示例：记住上次调用的值

package main

import "fmt"

// adder 返回一个闭包函数，每次调用会将传入的数值累加到之前的结果中
func adder() func(int) int {
    sum := 0 // 闭包中使用的外部变量
    return func(x int) int {
        sum += x // 记住并累积 sum 的状态
        return sum
    }
}

func main() {
    add := adder()
    fmt.Println(add(10)) // 输出：10
    fmt.Println(add(20)) // 输出：30，累积了之前的状态
    fmt.Println(add(5))  // 输出：35，再次累积了之前的状态
}

解释

adder 函数返回一个闭包函数，该闭包使用了外部变量 sum。
每次调用 add 时，闭包会记住 sum 的当前状态并累加传入的值，因此它能累积所有调用传入的值。

2. 创建自定义函数工厂

闭包常用于创建不同配置的函数。我们可以在闭包中定义一部分行为，让函数调用者提供另一部分参数，从而实现定制化的功能。

示例：构建带倍数的乘法函数

package main

import "fmt"

// multiplier 函数返回一个闭包，用于将输入的数值按指定倍数进行乘法运算
func multiplier(factor int) func(int) int {
    return func(x int) int {
        return x * factor // 闭包使用了外部的 factor 参数
    }
}

func main() {
    double := multiplier(2) // 创建一个乘以2的函数
    triple := multiplier(3) // 创建一个乘以3的函数

    fmt.Println(double(5)) // 输出：10
    fmt.Println(triple(5)) // 输出：15
}

解释

multiplier 是一个“工厂函数”，返回的闭包根据 factor 值创建不同的乘法函数。
double 和 triple 分别是倍数为 2 和 3 的函数，因此调用 double(5) 得到 10，调用 triple(5) 得到 15。

3. 计数器

闭包还可以用来实现简单的计数器，在每次调用时增加计数。

示例：简单计数器

package main

import "fmt"

// counter 返回一个闭包函数，该函数每次调用会将计数值增加1
func counter() func() int {
    count := 0 // 闭包中使用的外部计数变量
    return func() int {
        count++ // 增加计数值
        return count
    }
}

func main() {
    count := counter() // 获取一个计数器闭包

    fmt.Println(count()) // 输出：1
    fmt.Println(count()) // 输出：2
    fmt.Println(count()) // 输出：3
}

解释

counter 函数返回一个闭包，该闭包捕获了 count 变量的引用。
每次调用 count() 时，闭包会递增 count 的值并返回递增后的结果，因此这个计数器会持续增长。
总结
记住函数状态：闭包能够保存并累积外部变量的状态。
创建自定义函数工厂：闭包可以根据不同的外部变量返回定制化的函数。
计数器：闭包能够保留并修改自身的计数状态，每次调用都会更新。

3. 使用场景(2)

1. 延迟执行（用于资源清理、错误处理等）

闭包可以配合 defer 实现延迟执行，确保函数退出时执行一些清理或恢复操作。特别是在需要恢复被修改的状态或解锁资源时，闭包可以带来很大的便利。

示例：确保资源被正确释放

package main

import (
    "fmt"
    "sync"
)

func main() {
    var mu sync.Mutex
    mu.Lock() // 加锁资源

    // 使用 defer + 闭包来确保资源在函数结束时解锁
    defer func() {
        fmt.Println("Releasing lock...")
        mu.Unlock() // 延迟解锁
    }()

    fmt.Println("Performing operations with the lock...")
    // 此处可以执行一些操作，锁会在函数退出时自动解锁
}

解释

这里用闭包和 defer 延迟执行 mu.Unlock()，确保在函数退出时锁一定会被释放。
闭包捕获了外部变量 mu，实现了延迟执行和资源释放的效果。

2. 高阶函数（函数作为参数或返回值）

在 Go 中，可以将闭包作为参数传递给另一个函数，称为高阶函数。这在实现一些通用的处理逻辑时非常有用，比如排序、过滤或映射等操作。

示例：自定义筛选器函数

package main

import "fmt"

// filter 函数接收一个整数切片和一个闭包函数，用于过滤符合条件的元素
func filter(numbers []int, test func(int) bool) []int {
    var result []int
    for _, num := range numbers {
        if test(num) { // 调用闭包判断条件
            result = append(result, num)
        }
    }
    return result
}

func main() {
    numbers := []int{1, 2, 3, 4, 5, 6}

    // 传递闭包函数来筛选出偶数
    evenNumbers := filter(numbers, func(n int) bool {
        return n%2 == 0
    })
    fmt.Println("Even numbers:", evenNumbers) // 输出：[2 4 6]
}

解释

filter 函数接收一个闭包函数 test，用于测试哪些数字应该被保留。
filter 实现了通用的筛选逻辑，调用时只需传入不同的闭包，即可筛选出符合条件的数字。

3. 回调函数

闭包非常适合作为回调函数使用，尤其是在异步操作完成后执行一些处理时，可以传递闭包来作为回调操作。

示例：模拟异步操作中的回调

package main

import (
    "fmt"
    "time"
)

// performTask 模拟异步操作，并在完成后执行回调函数
func performTask(callback func(result string)) {
    time.Sleep(2 * time.Second) // 模拟一些延迟
    callback("Task completed")  // 完成后执行回调
}

func main() {
    fmt.Println("Starting task...")

    // 将闭包作为回调传递
    performTask(func(result string) {
        fmt.Println("Callback received:", result)
    })

    fmt.Println("Task submitted")
    time.Sleep(3 * time.Second) // 等待异步任务完成
}

解释

performTask 模拟一个异步操作，接受一个回调闭包 callback。
在任务完成后，callback 闭包被调用，将结果传回主程序。闭包可以在不引入额外的函数的情况下传递处理逻辑。

4. 实现装饰器模式

装饰器模式是一种用于在不改变函数本身的前提下扩展其功能的设计模式。在 Go 中，可以通过闭包实现装饰器，为函数添加额外的功能。

示例：日志装饰器

package main

import (
    "fmt"
    "time"
)

// logExecutionTime 是一个装饰器，用于测量函数执行时间
func logExecutionTime(fn func()) func() {
    return func() {
        start := time.Now()
        fn() // 执行被装饰的函数
        fmt.Printf("Execution time: %s\n", time.Since(start))
    }
}

func main() {
    task := func() {
        time.Sleep(2 * time.Second) // 模拟耗时操作
        fmt.Println("Task completed")
    }

    // 使用装饰器为 task 函数增加执行时间日志
    loggedTask := logExecutionTime(task)
    loggedTask() // 调用装饰后的函数
}

解释

logExecutionTime 是一个装饰器，它返回一个闭包函数。在闭包中，执行原始函数 fn 并记录执行时间。
通过闭包，我们可以为任意函数添加日志记录等功能，而不需要更改函数本身。

5. 延迟求值

在某些情况下，可能希望延迟计算一个值直到真正需要它时，这可以通过闭包实现“懒计算”。

示例：懒加载（延迟计算）

package main

import "fmt"

// lazyValue 返回一个闭包，该闭包在首次调用时才计算值
func lazyValue(f func() int) func() int {
    var value int
    var computed bool

    return func() int {
        if !computed {
            value = f()   // 第一次调用时计算值
            computed = true // 标记已计算
        }
        return value
    }
}

func main() {
    // 延迟计算的函数
    lazy := lazyValue(func() int {
        fmt.Println("Computing value...")
        return 42
    })

    fmt.Println(lazy()) // 输出 "Computing value..."，然后输出 42
    fmt.Println(lazy()) // 再次调用时不再计算，直接输出 42
}

解释

lazyValue 返回的闭包会在首次调用时执行 f() 并保存结果。之后的调用不再计算，而是直接返回缓存值。
这种模式在需要减少重复计算或懒加载某些资源时非常实用。

总结

闭包在 Go 中的应用场景非常广泛，主要包括：
1.资源管理与清理（如延迟释放、恢复状态）
2.高阶函数（如过滤、映射）
3.回调函数（如异步任务的回调）
4.装饰器模式（为函数添加功能）
5.延迟求值（实现懒加载）
这些场景充分利用了闭包捕获外部环境的能力，使代码更加简洁灵活。

原文地址：https://blog.csdn.net/2301_76723322/article/details/143665294

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

解决 Spring Boot 中 `Ambiguous mapping. Cannot map ‘xxxController‘ method` 错误
在使用 Spring Boot 开发 Web 应用时，经常会遇到各种各样的错误。其中一种常见的错误是。本文将详细介绍这个错误的原因及解决方法，帮助开发者快速定位并解决问题。解决错误的关键在于确保每个方
阅读更多2024-11-15
数据分析案例-笔记本电脑价格数据可视化分析
本实验数据集来源于Kaggle，原始数据集共有1303条数据，13个变量，各变量含义如下：0 laptop_ID-数字-产品ID1 Company-字符串-笔记本电脑制造商2 Product-字符串-
阅读更多2024-11-15
Linux 如何查看当前系统版本的详细信息？
系统中基本都存在，所以是一种标准的获取系统信息的方式。命令以标准的方式提供详细的发行版信息。发行版的说明文件一般位于。
阅读更多2024-11-15
初级数据结构——栈
数据结构栈（Stack）是一种线性的数据结构，它只允许在序列的一端（称为栈顶）进行插入和删除操作。这种特性使得栈成为许多算法和问题解决中的有力工具。栈是一种简单而强大的数据结构，它遵循后进先出的原则，
阅读更多2024-11-15
网络安全练习之 ctfshow_web
根据前面得到的qq邮箱中的qq号查询用户，目前电脑版的QQ添加好友好像不能查看详细信息，手机版的可以看到对方所在地为陕西西安。路径是：/editor/attached/file/tmp/html/no
阅读更多2024-11-15
Python 三种方式实现自动化任务
本文介绍了用Python实现机器人过程自动化的三个包，方便读者选择、对比学习。
阅读更多2024-11-15
C++基础：Pimpl设计模式的实现
PIMPL （ Private Implementation 或 Pointer to Implementation ）是通过一个私有的成员指针，将指针所指向的类的内部实现数据进行隐藏。
阅读更多2024-11-15
【flutter】flutter2升级到3.
以这个 https://github.com/aa286211636/Flutter_QQ 为例子，升级下看看。只有登录界面能正常显示，别的页面都是报错。flutter这版本变动，基本不能直接ru
阅读更多2024-11-15
【JAVA毕业设计】基于Vue和SpringBoot的宠物咖啡馆平台
基于Vue.js和SpringBoot的宠物咖啡馆平台是一个综合性的在线服务系统，旨在为宠物爱好者提供一个便捷的宠物护理和社交场所。该平台分为管理后台和用户网页端，以满足不同用户群体的需求。管理后台主
阅读更多2024-11-15
认证鉴权框架SpringSecurity-2--重点组件和过滤器链篇
这4个接口中，每一个都是当认证或者授权过程中发生结果后触发，可以是失败的场景也可以是成功后触发。1个成功后执行，3个为失败后促发执行。
阅读更多2024-11-15