Go | 闭包的使用

简介: Go | 闭包的使用

闭包基本介绍


闭包就是 一个函数 和其相关的 引用环境 组合的一个整体

好处: 保存引用的变量,下次继续使用,不会销毁

下面通过闭包的方式,写一个数字累加器,体验一下闭包的妙处👇


闭包实现数字累加


package main
import "fmt"
// 累加器
// 闭包 - 函数柯里化
// 返回值类型: func(int) int
func AddUpper() func(int) int {
  var n int = 100
  return func(i int) int {
    n = n + i
    return n
  }
}
func main() {
  f := AddUpper()
  fmt.Println(f(1)) // 101
  fmt.Println(f(2)) // 103
  fmt.Println(f(3)) // 106
}


代码说明


  1. AddUpper是一个函数,返回的数据类型 func(int) int


  1. 闭包的说明

image.png

返回的是一个匿名函数,但是这个匿名函数引用到了函数外的变量 n ,因此这个匿名函数就和 n 形成一个整体,构成闭包


  1. 当反复调用 f 函数时,因为 n 只初始化一次,保存了变量的值,因此每调用一次就相当于进行了累加。


  1. 我们要搞清楚闭包,关键就是要分析返回的函数使用到哪些变量


代码分析


这里我引入了一个字符串变量str,来帮助分析闭包是怎么保存变量的。

package main
import (
  "fmt"
)
// 累加器
// 闭包 - 函数柯里化
// 返回值类型: func(int) int
func AddUpper() func(int) int {
  var n int = 100
  var str = "hello"
  return func(i int) int {
    n = n + i
    fmt.Println("i=", i)
    str += string(36) // ascii 36 = '$'
    fmt.Printf("str==%s\n", str)
    return n
  }
}
func main() {
  f := AddUpper()
  // fmt.Println(AddUpper()(1)) // 101
  fmt.Println("f(1)=", f(1)) // 101
  fmt.Println("f(2)=", f(2)) // 103
  fmt.Println("f(3)=", f(3)) // 106
}
i= 1
str==hello$
f(1)= 101
i= 2
str==hello$$
f(2)= 103
i= 3
str==hello$$$
f(3)= 106

从输出可以看出来,闭包引用的变量nstr并没有在调用函数的时候重复声明,而是保留了下次函数调用后更新的值。


闭包案例


需求:


  1. 编写一个函数 makeSuffix(suffix string) ,可以接收一个文件后缀名,并返回一个闭包


  1. 调用闭包,可以传入一个文件名,如果该文件名没有指定后缀,则返回 文件名.jpg ,如果已经有.jpg,则返回原文件名。


strings.HasSuffix,该函数可以判断某个字符串是否有指定的后缀。


上代码


package main
import (
  "fmt"
  "strings"
)
func makeSuffix(suffix string) func(string) string {
  return func(name string) string {
    if !strings.HasSuffix(name, suffix) {
      return name + suffix
    }
    return name
  }
}
// 传统写法
func makeSuffixV2(suffix string, name string) string {
  if !strings.HasSuffix(name, suffix) {
    return name + suffix
  }
  return name
}
func main() {
  // 闭包调用
  f := makeSuffix(".jpg")
  fmt.Println(f("xiao"))         // xiao.jpg
  fmt.Println(f("xiaoxiao.jpg")) // xiaoxiao.jpg
  fmt.Println(f("xiaoxiao.666")) // xiaoxiao.666.jpg
  // 传统写法调用
  fmt.Println("makeSuffixV2=", makeSuffixV2(".jpg", "allblue"))  // makeSuffixV2= allblue.jpg
  fmt.Println("makeSuffixV2=", makeSuffixV2(".jpg", "all.blue")) // makeSuffixV2= all.blue.jpg
}


代码说明


返回的匿名函数和 makeSuffix(suffix string) 的 suffix 变量组合成一个闭包

传统写法和闭包写法实现效果一样,但是,传统写法需要重复写变量, 比如上面的

makeSuffixV2(".jpg", "all.blue"))


闭包则解决了这个问题,是代码看起来更加的简洁


闭包的好处之一: 参数复用


好处: 保存引用的变量,下次继续使用,不会销毁


目录
相关文章
|
7月前
|
Go
Go 语言使用 goroutine 运行闭包的“坑”
Go 语言使用 goroutine 运行闭包的“坑”
38 0
|
7月前
|
Serverless Go
Go语言闭包不打烊,让你长见识!
Go语言闭包不打烊,让你长见识!
30 0
|
4天前
|
Go C++
go 语言回调函数和闭包
go 语言回调函数和闭包
|
4天前
|
存储 编译器 Go
GO闭包实现原理(汇编级讲解)
函数闭包一点也不神秘,它就是函数和引用环境而组合的实体。在Go中,闭包在底层是一个结构体对象,它包含了函数指针与自由变量。Go编译器的逃逸分析机制,会将闭包对象分配至堆中,这样自由变量就不会随着函数栈的销毁而消失,它能依附着闭包实体而一直存在。因此,闭包使用的优缺点是很明显的:闭包能够避免使用全局变量,转而维持自由变量长期存储在内存之中;但是,这种隐式地持有自由变量,在使用不当时,会很容易造成内存浪费与泄露。附着闭包实体而一直存在。
50 0
GO闭包实现原理(汇编级讲解)
|
9月前
|
存储 Rust 算法
Go中的匿名函数与闭包
Go中的匿名函数与闭包
50 0
|
JavaScript 前端开发 Java
Go中的闭包、递归
Go中的闭包、递归
46 1
|
安全 Go
Go函数下篇:defer和闭包
Go函数下篇:defer和闭包
|
JavaScript 前端开发 Java
|
Go 索引 Python
Go 和Python中的闭包实现及使用
Go 和Python中的闭包实现及使用
95 0
|
存储 缓存 Go
【Golang之路】——匿名函数和闭包
【Golang之路】——匿名函数和闭包
113 0