【Go】Go语言中延迟函数、函数数据的类型、匿名函数、闭包等高阶函数用法与应用实战

于 2024-09-14 14:26:08 发布
阅读量784 收藏 9
点赞数 8
分类专栏： Go语言开发零基础到高阶实战 文章标签： golang 后端 defer 匿名函数 闭包 回调函数 go函数数据类型
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/littlefun591/article/details/142257000
版权

在这里插入图片描述

✨✨ 欢迎大家来到景天科技苑✨✨

🎈🎈 养成好习惯，先赞后看哦~🎈🎈

🏆 作者简介：景天科技苑
🏆《头衔》：大厂架构师，华为云开发者社区专家博主，阿里云开发者社区专家博主，CSDN全栈领域优质创作者，掘金优秀博主，51CTO博客专家等。
🏆《博客》：Python全栈，Golang开发，PyQt5和Tkinter桌面开发，小程序开发，人工智能，js逆向，App逆向，网络系统安全，数据分析，Django，fastapi，flask等框架，云原生K8S，linux，shell脚本等实操经验，网站搭建，数据库等分享。

所属的专栏：Go语言开发零基础到高阶实战
景天的主页：景天科技苑

在这里插入图片描述

文章目录

函数进阶

1. 延迟函数(defer)

defer语句在Go语言中是一个强大的特性，它允许你延迟函数的执行直到包含它的函数即将返回。这通常用于清理资源、解锁互斥锁、记录时间、关闭文件等操作。
比如说我们打开一个文件，我们判断它有没关闭，我们希望所有代码执行完，最后调用defer函数来关闭文件

语法格式：
defer 函数调用
注意：

defer语句会将其后的函数调用压入一个栈中，当外层函数即将返回时，这些被defer的函数会按照后进先出（LIFO）的顺序执行。
defer可以在函数中多次使用，以注册多个需要延迟执行的函数。

package main

import "fmt"

// defer
func main() {
    f("1")
    fmt.Println("2")
    //其他语句执行完，再执行defer包含的函数
    defer f("3")
    fmt.Println("4")
}

func f(s string) {
    fmt.Println(s)
}

可以看到3最后打印
在这里插入图片描述
流程分析
在这里插入图片描述

defer函数或者方法：一个函数或方法的执行被延迟了

  • 你可以在函数中添加多个defer语句，当函数执行到最后时，这些defer语句会按照逆序执行，最后该函数返回，特别是当你在进行一些打开资源的操作时i/o 流，遇到错误需要提前返回，在返回前你需要关闭相应的资源，不然很容易造成资源泄露等问题
  • 如果有很多调用 defer，那么 defer 是采用 后进先出（栈） 模式。
  • 你可以在函数中添加多个defer语句，当没有加defer的语句执行完毕后，这些defer语句会按照逆序执行

多个defer案例：

package main

import "fmt"

// defer 作用：处理一些善后的问题，比如错误，文件、网络流关闭等等操作。
// 特点，多个defer的问题
// 不加defer的语句还是按顺序从上而下执行
// 你可以在函数中添加多个defer语句，当没有加defer的语句执行完毕后，这些defer语句会按照逆序执行
func main() {
    f("1")
    defer fmt.Println("2")
    defer f("3")
    fmt.Println("4")
    defer f("5")
    fmt.Println("6")
    defer f("7")
    fmt.Println("8")
}

func f(s string) {
    fmt.Println(s)
}

在这里插入图片描述

defer存在传递参数：
在defer的时候，函数其实已经被调用了，但是没有执行。参数是已经传递进去的了

package main

import "fmt"

// defer传参的调用时机
func main() {
    n := 10
    fmt.Println("main n=", n)
    // 在defer的时候，函数其实已经被调用了，但是没有执行。参数是已经传递进去的了
    defer ff(n) // 问题，defer延迟执行函数，参数时什么时候传递进去？在其他地方虽然n已经加1了，ff函数最后执行，但是ff函数中的n还是10，说明参数是先加载进来，只是没执行函数
    n++
    fmt.Println("main end n=", n)

    defer ff(n) //如果ff在n加1之后defer延迟执行，参数中的n是加1后的n
}

func ff(n int) {
    fmt.Println("ff函数中n=", n)
}

在这里插入图片描述

defer后续常用场景：程序会报错： 异常（程序执行的时候突然报错了）、错误（我们开发的时候知道的预期错误）

善后工作：defer 处理异常。

2. 函数的数据类型

  • func （xxxx,xxx） xxx,xxxx
  • 函数也是一种数据类型，可以定义函数类型的变量
package main

import "fmt"

// 函数是什么（数据类型）
func main() {
    a := 10.01
    fmt.Printf("%T\n", a) // 查看变量的类型
    b := [4]int{1, 2, 3, 4}
    fmt.Printf("%T\n", b) // 查看变量的类型
    c := true
    fmt.Printf("%T\n", c) // 查看变量的类型

    // 函数的类型
    func1()                   // 带了括号是函数的调用
    fmt.Printf("%T\n", func1) // 查看变量的类型 func()
    fmt.Printf("%T\n", func2) // 查看变量的类型 func(int, int, ...string) (int, int)
    // func(int, int) (int, int)
    // func(int, int, ...string) (int, int)
    //var fun3 func(int, int, ...string) (int, int)
    fun3 := func2
    r1, r2 := fun3(1, 2, "111")
    fmt.Println(r1, r2)
    // 函数在Go语言中本身也是一个数据类型，加了（） 是调用函数，不加（）, 函数也是一个变量，可以赋值给别人。

    // 函数的类型就等于该函数创建的类型，他也可以赋值给
}

// 无参无返回值的函数
func func1() {

}

// 有参有返回值的函数
func func2(a, b int, c ...string) (int, int) {
    return 0, 0
}

在这里插入图片描述

3. 函数的本质

函数在Go语言中不是一个简单的调用或者接收结果的。

函数在Go中是一个符合类型，可以看做是一个特殊的变量。var 定义吗，赋值。类型相同即可

函数类型的样子 ：var f1 函数名(参数) 结果

变量名：指向一段内存 （num --> 0x11111aaaa）

函数名：指向一段函数体的内存地址，是一种特殊类型的变量。我们可以将一个函数赋值给另外一个类型相同的函数
在这里插入图片描述

4. 匿名函数

Go语言支持匿名函数，即没有名称的函数。匿名函数通常用于实现局部的、一次性的功能，或者作为高阶函数的参数传递。
匿名函数，在函数体后增加()，调用了这个函数，匿名函数只能一次。
将匿名函数进行赋值，就可以实现多次调用。

Go语言支持函数式编程

  • 将匿名函数作为另外一个函数的参数，回调函数
  • 将匿名函数作为另外一个函数的返回值，可以形成闭包结构
package main

import "fmt"

// 匿名变量 （没有名字的变量）
// 匿名函数 （没有名字的函数）
func main() {
    // 正常的调用
    f12()
    f2 := f12 // 函数赋值给另外一个函数
    f2()
    // f12  f2 本质指向了同一个内存空间，空间中的代码一致  {fmt.Println("我是f12函数")}

    // 匿名函数，在函数体后增加()，调用了这个函数，匿名函数只能一次。
    func() {
        fmt.Println("我是一个匿名函数1")
    }()

    // 将匿名函数进行赋值，就可以实现多次调用。
    f3 := func() {
        fmt.Println("我是一个匿名函数2")
    }
    //将匿名函数赋值给变量后，可以直接通过变量调用
    f3()

    // 匿名函数是否可以添加参数和返回值
    func(a, b int) {
        fmt.Println("a,b")
    }(1, 2)

    // 将匿名函数的返回值定义给变量。
    r1 := func(a, b int) int {
        return a + b
    }(1, 2)
    fmt.Println(r1)

    // 由于Go语言中的函数是一个特殊的变量，支持匿名操作
    // Go语言支持函数式编程
    // - 将匿名函数作为另外一个函数的参数，回调函数
    // - 将匿名函数作为另外一个函数的返回值，可以形成闭包结构

}
func f12() {
    fmt.Println("我是f12函数")
}

在这里插入图片描述

5. 回调函数

高阶函数：可以将一个函数作为另外一个函数的参数。

fun1()

fun2(fun1)

fun1 函数作为 fun2 函数的参数

fun2函数，叫做高阶函数，接收了另外一个函数作为参数的函数

fun1函数，叫做回调函数，作为另外一个函数的参数

package main

import "fmt"

// 回调函数
func main() {
    // 函数调用
    r1 := add(1, 2)
    fmt.Println("r1是:", r1)
    // 高阶函数调用
    r2 := oper(1, 2, add)
    fmt.Println("r2是:", r2)
    r3 := oper(1, 2, sub)
    fmt.Println("r3是:", r3)

    // 匿名函数
    fun1 := func(a, b int) int {
        return a * b
    }
    r4 := oper(1, 2, fun1) // 调用匿名函数 *
    fmt.Println("r4是:", r4)

    // 能够直接传递匿名函数
    r5 := oper(8, 2, func(a int, b int) int {
        if b == 0 {
            fmt.Println("除数不能为0")
            return 0
        }
        return a / b
    })
    fmt.Println("r5是:", r5)
}

// 运算 (运算的数字，运算操作)
// 高阶函数，参数是接收另外一个函数
func oper(a, b int, fun func(int, int) int) int {
    //打印出的fun是每次传入的函数内存地址
    fmt.Println(a, b, fun)
    r := fun(a, b)
    return r
}

func add(a, b int) int {
    return a + b
}
func sub(a, b int) int {
    return a - b
}

在这里插入图片描述

函数也可作为可变参数传参
在这里插入图片描述

6. 闭包

一个外层函数中，有内层函数，该内层函数中，会操作外层函数的局部变量
并且该外层函数的返回值就是这个内层函数。
这个内层函数和外层函数的局部变量，统称为闭包结构。

局部变量的生命周期就会发生改变，正常的局部变量会随着函数的调用而创建，随着函数的结束而销毁
但是闭包结构中的外层函数的局部变量并不会随着外层函数的结束而销毁，因为内层函数还在继续使用

package main

import "fmt"

// 是一种特殊的结构：闭包结构，违反了程序正常的生命周期。合法的使用。程序允许的一种特殊结构，变量作用域升级了。

// 什么时候用闭包： js （xxxxxxx.html   引用大量的第三方库：10个js库，js库中很多变量名是冲突的）
// js 很多框架都是闭包结构的，防止变量冲突，全局变量污染

// 我的代码里面的变量就不会和你代码里面的变量冲突了。解决一些变量作用域冲突的问题。

/*
闭包结构:
一个外层函数中，有内层函数，该内层函数中，会操作外层函数的局部变量并且该外层函数的返回值就是这个内层函数。

在闭包结构中：局部变量的生命周期就会发生改变，
正常的局部变量会随着函数的调用而创建，随着函数的结束而销毁
但是闭包结构中的外层函数的局部变量并不会随着外层函数的结束而销毁，因为内层函数还在继续使用.

// 由于垃圾回收期不会将闭包中的变量销毁，可能会造成内存泄漏。
*/

// 你的代码变量和你同事的变量冲突了，解决。 i 新建一个变量。 第三方库中的代码都是闭包结构实现的导出。
var i int = 10

func main() {
    r1 := increment()
    fmt.Println(r1) // 返回的是一个 increment() 内层函数，还没有执行
    // -- 执行这个内层函数
    //
    v1 := r1()
    fmt.Println(v1)
    v2 := r1()
    fmt.Println(v2)
    fmt.Println(r1())
    fmt.Println(r1())
    fmt.Println(r1())
    // 你写的代码是对的，但是结果不对，你的变量被污染了
    fmt.Println("--------------------------")

    // r2和r1指向同一个地址
    r2 := increment() // 再次调用的时候 ，i = 0
    v3 := r2()
    fmt.Println(v3) // 1

    //因为我们内层还是用i，还存在引用，系统不会销货这个i，保护，单独作用r1
    fmt.Println(r1()) // 6     // 这里的i 并没有随着 第二次创建就被销毁归0，而是在内层函数继续调用着。
    fmt.Println(r2()) // 2
    // r1 名字 ----> 内存地址 &r1
    fmt.Printf("%p\n", &r1)
    fmt.Printf("%p\n", &r2)

}

// 自增函数
// increment() 函数返回值为  func() int 类型
func increment() func() int { // 外层函数，项目（很多的全局变量）
    // 定义一个局部变量
    i := 0
    // 在外层函数内部定义一个匿名函数，给变量自增并返回。
    fun := func() int {
        i++
        return i
    }
    return fun
}

在这里插入图片描述

如果我们想使用闭包结构来解决全局变量污染的问题，那我们就可以写一个闭包结构来创建执行的函数。

通过这个闭包结构创建的函数内部的变量，都在这个函数中作用，不会和其他函数冲突。

**闭包结果的返回值是一个函数。**这个函数可以调用闭包结构中的变量。

package main

import "fmt"

// 是一种特殊的结构：闭包结构，违反了程序正常的生命周期。合法的使用。程序允许的一种特殊结构，变量作用域升级了。

// 什么时候用闭包： js （xxxxxxx.html   引用大量的第三方库：10个js库，js库中很多变量名是冲突的）
// js 很多框架都是闭包结构的，防止变量冲突，全局变量污染

// 我的代码里面的变量就不会和你代码里面的变量冲突了。解决一些变量作用域冲突的问题。

/*
闭包结构:
一个外层函数中，有内层函数，该内层函数中，会操作外层函数的局部变量并且该外层函数的返回值就是这个内层函数。

在闭包结构中：局部变量的生命周期就会发生改变，
正常的局部变量会随着函数的调用而创建，随着函数的结束而销毁
但是闭包结构中的外层函数的局部变量并不会随着外层函数的结束而销毁，因为内层函数还在继续使用.

// 由于垃圾回收期不会将闭包中的变量销毁，可能会造成内存泄漏。
*/

// 你的代码变量和你同事的变量冲突了，解决。 i 新建一个变量。 第三方库中的代码都是闭包结构实现的导出。
var i int = 10

func main() {
    r1 := increment()
    fmt.Println(r1) // 返回的是一个 increment() 内层函数，还没有执行。直接打印函数名得到的是名字的地址
    // -- 执行这个内层函数
    //
    v1 := r1()
    fmt.Println(v1)
    v2 := r1()
    fmt.Println(v2)
    fmt.Println(r1())
    fmt.Println(r1())
    fmt.Println(r1())
    // 你写的代码是对的，但是结果不对，你的变量被污染了
    fmt.Println("--------------------------")

    // r2和r1指向同一个地址
    r2 := increment() // 再次调用的时候 ，i = 0
    v3 := r2()
    fmt.Println(v3) // 1

    //因为我们内层还是用i，还存在引用，系统不会销货这个i，保护，单独作用r1
    fmt.Println(r1()) // 6     // 这里的i 并没有随着 第二次创建就被销毁归0，而是在内层函数继续调用着。
    fmt.Println(r2()) // 2
    // r1 名字 ----> 内存地址 &r1
    fmt.Printf("%p\n", &r1)
    fmt.Printf("%p\n", &r2)

}

// 自增函数
// increment() 函数返回值为  func() int 类型
//通过increment()可以创建无数个函数，让incremnet()变量不会影响每个函数的使用

func increment() func() int { // 外层函数，项目（很多的全局变量）
    // 定义一个局部变量
    i := 0
    // 在外层函数内部定义一个匿名函数，给变量自增并返回。
    fun := func() int {
        i++
        return i
    }
    return fun
}

在这里插入图片描述

闭包计算斐波那契数

package main

import "fmt"

// 返回一个“返回类型为int的函数” ，将闭包函数作为值返回
func fibonacci() func() int {
    a, b := 1, 1 //定义初始的两个值
    return func() int {
        c := a
        a, b = b, a+b
        return c
    }
}

func main() {
    f := fibonacci()
    //计算前10个斐波那契数列
    for i := 0; i < 10; i++ {
        fmt.Println(f())
    }
}

在这里插入图片描述

景天科技苑
关注
专栏目录
Go语言 一级函数 --- 匿名函数、高阶函数、闭包
qq_19018277的博客
04-03 571
Go语言 的一级函数是啥呢？
Scala函数（函数的定义，匿名函数，高阶函数，内嵌函数，柯里化函数，隐式参数，隐式函数，闭包）（二）
May_J_Oldhu的博客
01-07 594
Scala函数一.Scala函数1.函数定义2.函数调用2.1 传值调用2.2传名调用2.3参数默认值2.4命名参数二.匿名函数三.高阶函数1.函数作为参数2.函数作为返回值3.函数字面量短格式（匿名函数精简格式）4.各个内置高阶函数四.内嵌函数1.内嵌函数的作用五.柯里化函数六.隐式参数七.隐式函数1.隐式转换2.类型增强八.闭包 一.Scala函数 1.函数定义 def functionName ([参数名:参数类型],…) [: return type]={ 函数主体 } 如果省略函数名称则变为匿名
Kotlin中匿名函数（又称为Lambda，或者闭包）和高阶函数的详解
路宇的博客
01-18 1053
7、函数类型作为返回值类型、以及闭包。8、lambda表达式与匿名内部类。3、函数的参数是另一个函数。2、Lambda的概述。2、kotlin代码。
Go语言实战:函数和接口之匿名函数和闭包
程序员光剑
01-21 856
1.背景介绍 1.背景介绍 Go语言是一种现代编程语言，由Google的Robert Griesemer、Rob Pike和Ken Thompson在2009年开发。Go语言的设计目标是简洁、高效、可扩展和易于使用。它的核心特点是强类型、垃圾回收、并发性能等。Go语言的标准库非常丰富，可以用来开发各种类型的应用程序，如网络服务、数据库系统、操作系统等。 在Go语言中，函数是一种首要的构建块，...
Go中的匿名函数与闭包
Go中国
08-17 172
关键词: 函数式编程 闭包 匿名函数 匿名函数特别适合作为函数或方法的回调 在Go中函数是一等公民，和string，int等一样。而在C、C++ 等不支持匿名函数的语言中，函数不能在运行期创建go 学习笔记之仅仅需要一个示例就能讲清楚什么闭包题图来自https://www.meetgor.com/golang-closures/闭包 与 普通函数的区别在(普通)函数里面定义一个内部函...
Go语言之函数,返回值,作用域,传参,匿名函数,高阶函数,闭包函数
凯歌技术控团队
07-17 621
真正运行函数内的代码还需要对声明的函数进行调用，一个函数可以在任意位置多次调用。调用一次，即执行一次该函数内的代码。这样当然可以实现，但是是不是依然有大量重复代码，一会发现三个函数出了一个变量值不同以外其他都是相同的，所以为了能够在函数调用的时候动态传入一些值给函数，就有了参数的概念。这就涉及到了函数参数。函数每次调用可以传入不同的实际参数，传参的过程其实就是变量赋值的过程，将实际参数按位置分别赋值给形参。这样是不是就灵活很多了呢，所以基本上一个功能强大的函数都会有自己需要的参数，让整个业务实现更加灵活。
go中函数高级用法:匿名、闭包及高阶函数
赵凯月的博客
05-09 51
有了闭包后函数就成为了一个变量的值，只要变量没被释放，函数就会一直处于存活并独享的状态，因此可以后期更改函数中变量的值（因为这样就不会被go给回收内存了，会一直缓存在那里）。然后在下面声明的函数printToStd的签名与Printer的是一致的，因此前者是后者的一个实现，即使它们的名称以及有的结果名称是不同的。只要两个函数的参数列表和结果列表中的元素顺序及其类型是一致的，我们就可以说它们是一样的函数，或者说是实现了同一个函数类型的函数。只要满足了其中任意一个特点，我们就可以说这个函数是一个高阶函数。
go的函数定义、递归、延迟、匿名、高阶、闭包
一起coding，一起嗨。
02-08 876
【代码】go的函数定义、递归、延迟、匿名、高阶、闭包。
python 函数 函数的偏函数 高阶函数 返回函数 匿名函数 闭包.md
07-26
### Python 函数进阶...以上内容涵盖了偏函数、高阶函数、返回函数、匿名函数以及闭包等 Python 中重要的函数概念和实现方法。通过这些知识点的学习和理解，可以帮助开发者更高效地编写出结构清晰、易于维护的代码。
Python 中的闭包、匿名函数、decorator 装饰器与python的偏函数
12-21
在Python编程语言中，闭包、匿名函数和装饰器是三种重要的高级概念，它们扩展了函数的功能和灵活性。下面将详细解释这些概念及其应用。 **闭包（Closure）** 闭包是指一个函数能够记住它被创建时的环境，即它可以...
Go语言中的函数式编程实践
09-20
通过以上讨论，我们可以看到Go语言虽然不是纯函数式编程语言，但其支持闭包和接口等特性，使得开发者可以在Go中实践函数式编程的理念，如不可变性、纯函数、高阶函数等。这些特性有助于编写简洁、可测试和易于理解的...
PHP中的闭包（匿名函数）浅析
10-24
这种特性在处理回调函数或是高阶函数时特别有用，同时闭包也使得代码更加简洁和灵活。 闭包的使用方法相对简单，但需要理解其原理才能更好地应用。例如，在PHP中，我们可以通过array_map函数结合匿名函数对数组元素...
Go语言 管道1
最新发布
json_li的博客
09-11 625
本篇文章主要介绍Go语言 无缓冲管道和有缓冲管道概念，特点及其使用示例。
golang学习笔记16——golang部署与运维全攻略
GoppViper的博客
09-11 1033
Golang 的部署和运维需要考虑多个方面，包括部署方式的选择、跨平台问题、日志和监控以及性能优化等。通过合理的部署和运维策略，可以确保 Golang 应用的稳定运行和高效性能。在实际应用中，需要根据具体情况选择合适的方法，并不断进行优化和改进。关注我看更多有意思的文章哦！👉👉。
go系列之 cron 表达式
qq_37011724的博客
09-09 411
cron 是一个用于 Go 语言的定时任务调度库
golang入门
m0_51866860的博客
09-06 661
学习视频：PATH。
Go语言设计与实现 学习笔记 第六章 并发编程（3）
tus00000的博客
09-07 1087
会返回可读或者可写事件（如上，还有异常事件）的个数，应用程序就可以在输入的文件描述符中（实际上，select函数会通过参数返回哪些fd可用，例如通过readfds参数返回可读的fd集合，通过writefds参数返回可写的fd集合）查找哪些可读或可写（或异常），然后执行相应的操作。Go语言的系统监控也起到了很重要的作用，它在内部启动了一个不会中止的循环，在循环的内部会轮询网络、抢占长期运行或处于系统调用的Goroutine、触发垃圾回收，通过这些行为，它能够让系统的运行状态变得更健康。
深入解析Go语言的容器包
一个被知识诅咒的人
09-10 792
本文详细介绍了Go语言中的容器包，重点讲解了如何使用`container/ring`和`container/list`实现环形链表和双向链表。通过具体的代码示例，演示了环形链表的创建、遍历以及对每个节点进行操作的方法，说明了其在循环处理任务中的应用。还展示了双向链表的插入、删除和遍历操作，解释了链表在实际开发中的灵活性和高效性。通过这些实例，读者可以深入理解并灵活应用Go中的数据结构。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

景天科技苑

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值