欣语漫言

外观

匿名函数 ​

作者: ryan 发布于: 2025/7/11 更新于: 2025/7/11 字数: 0 字 阅读: 0 分钟

匿名函数是一种没有名称的函数，可以直接定义并在需要的地方使用，常用于简化代码或实现局部逻辑封装。

匿名函数的核心特性 ​

无函数名 ​

匿名函数通过 func 关键字定义，但省略函数名称。这种设计使其成为一次性使用的临时函数。

go
// 定义并立即调用
func(x, y int) {
    fmt.Println(x + y)
}(4, 5) // 输出：9

灵活的作用域绑定 ​

匿名函数能直接访问其定义位置的外部变量，形成闭包（Closure），使函数携带状态：

go
count := 0
increment := func() {
    count++ // 访问外部变量
}
increment() // count 变为 1

匿名函数定义 ​

Go 不允许在 main 函数外的包级别直接调用匿名函数（除非赋值给全局变量），匿名函数的执行必须位于函数内部（如 main 或其他函数）

这种写法会被编译器识别为未定义行为.

go
package main  
  
func(x, y int) int {  
     return x + y  
}(4, 5)

func main() {  
}

正确使用方法 ​

1.在函数内部立即调用 ​

将匿名函数移至 main 函数内部，并加 () 执行：

go
package main  
  
func main() {  
    func (x,y int) {   // 定义并立即调用
         
    }(4,5) // 函数定义后面或函数标识符后 接小括号就是调用  
}

2. 赋值给变量再调用 ​

在 main 中先赋值匿名函数到变量，再通过变量调用：

go
package main
import "fmt"

func main() {
    // 将匿名函数赋值给变量
    add := func(x, y int) int {
        return x + y
    }
    fmt.Println(add(4, 5)) // 输出: 9
}

3.全局匿名函数 ​

若需全局访问，可将匿名函数赋值给全局变量

go
package main
import "fmt"

// 包级变量保存匿名函数
var Add = func(x, y int) int {
    return x + y
}

func main() {
    fmt.Println(Add(4, 5)) // 输出: 9
}

定义方式与复用性 ​

这三种种写法有什么区别？

go
var add1 = func(x, y int) int {  
    return x + y  
}  
  
func add2 (x, y int) int {  
    return x + y  
}

func(x, y int) int { return x + y }(1, 2)

匿名函数赋值给变量 ​

go
var add1 = func(x, y int) int {  
    return x + y  
}

匿名函数本身无名称，但通过赋值给变量 add1 间接实现复用。 add1 作为函数类型变量，其作用域决定了复用范围

具名函数 ​

go
func add2 (x, y int) int {  
    return x + y  
}

这种写法是 Go 函数的传统定义形式，有明确名称 add2，可在其作用域内（包级或函数内部）通过函数名任意多次复用。

立即执行的匿名函数 ​

“一次性”函数
无变量引用，执行后即销毁，无法复用

go
func(x, y int) int { return x + y }(1, 2)

高阶函数 ​

满足以下任一条件就是高阶函数了

1. 形参定义为函数类型
2. 返回值是函数类型

高阶函数使用 ​

我想用2个整数计算，但是未来使用什么计算，我不确定，可能是加法，也可能是乘法，也可能是减法

目的：将整数计算的操作外移，在调用时决定到底是加法，乘法，还是减法。

go

package main  
  
import "fmt"  
  
//高阶函数：接收函数类型参数 `fn`  fn 的类型是 fn func(x, y int) int
func calc(a, b int, fn func(x, y int) int) {    //函数签名中的 `fn func(x, y int) int` 表明它接收一个函数类型参数。
    //a * b 这里对 a、b的操作是什么？ 目前不知道  所以当前操作就应该抽象成占位符  
    result := fn(a, b)  //调用传入的函数逻辑
    fmt.Println("计算结果是=", result)  
}  
  
func main() {  

// 定义加法匿名函数
    var add = func(x, y int) int {  
       return x + y  
    }  
    fmt.Printf("%T\n", add)  // 查看add的类型 输出: func(int, int) int
    
// 将加法函数传入 calc
    calc(4, 5, add)  
}

输出结果：

go
func(int, int) int
计算结果是= 9

灵活使用匿名函数add 是一个匿名函数变量，通过 func(x, y int) int {...} 定义。其类型与 calc 的 fn 参数完全匹配

核心思想：将具体计算逻辑作为参数传递，实现操作的灵活扩展。