Go语言函数核心用法与参数传递机制

Go函数的本质与定义

在Go语言中，函数（Function）是执行特定功能的独立代码块。通过封装功能逻辑，函数能够显著提高代码的复用性并减少冗余，使程序结构更加模块化。

第1步：理解函数的五大组成部分

一个标准的Go函数声明通常包含以下五个关键部分，以下案例用于两数求和：

func Add(num1 int, num2 int) int {
    var sum int
    sum += num1
    sum += num2
    return sum
}

• 关键字：必须使用 func 开头。
• 函数名：推荐使用驼峰命名法。首字母大写可被外部包调用（导出），小写仅在当前包内可用。
• 参数列表：位于函数名后括号内，多个参数需以逗号分隔。
• 返回值列表：若有多个返回值需用括号包裹并以逗号分隔。返回值名称可显式声明（如 sum int），但通常情况下只需声明类型。
• 函数体：大括号内的具体逻辑实现。需要注意的是，参数和返回值在某些场景下是可以省略的。

灵活参数处理：变长参数

当需要处理的参数数量不确定时，可以使用变长参数。变长参数本质上是一个切片，允许接收不定量的同类型参数。

func main() {
    sum := Add(1, 2, 3, 4)
    println(sum) // 输出: 10
}

func Add(nums ...int) int {
    var sum int
    for _, num := range nums {
        sum += num
    }
    return sum
}

通过在类型前添加 ... 来声明可变参数。内部逻辑可使用 for-range 遍历该切片完成操作。

匿名函数与闭包机制

对于仅需使用一次的逻辑，可以直接使用匿名函数；而闭包则是匿名函数与其引用环境组合的整体，常用于保持状态。

匿名函数的两种调用方式

1. **直接调用**：定义后立即执行。

result := func(num1, num2 int) int {
    return num1 + num2
}(1, 2)

2. **赋值调用**：将匿名函数赋给变量后多次调用。

addFunc := func(num1, num2 int) int {
    return num1 + num2
}
println(addFunc(1, 2))

闭包的状态保持

闭包的核心在于其捕获的环境变量会常驻内存。例如：

import "fmt"

func getSum() func(int) int {
    var sum int = 0
    result := func(num int) int {
        sum += num
        return sum
    }
    return result
}

func main() {
    f := getSum()
    fmt.Println(f(1)) // 1
    fmt.Println(f(2)) // 3 (累加)

可以看到，每次调用 f 时，共享的外部变量 sum 值会持续累加。

初始化流程：init 函数

每个Go文件可包含一个 init 函数，专门用于初始化操作。其执行优先级高于 main 函数。

var print = getNum()

func getNum() int {
    println("初始化变量")
    return 1
}

func init() {
    println("init...")
}

func main() {
    println("main...")
}

执行顺序：
全局变量初始化 → init 函数 → main 函数。
若涉及多文件，则先执行所导入模块的 init，再执行当前文件的 init。

参数传递深层解析

清晰区分形式参数（形参）与实际参数（实参），并掌握不同数据类型的传递方式是避免Bug的关键。

值传递：基本数据与数组的特性

对于基本数据类型和数组，Go默认采用值传递。这意味着函数内部会创建一个副本，对其修改不会影响外部原始数据。

func main() {
    num1, num2 := 1, 2
    Swap(num1, num2)
    fmt.Printf("main: %d, %d\n", num1, num2) // 结果仍为 1, 2
}

func Swap(a, b int) {
    a, b = b, a // 仅交换了副本
    fmt.Printf("Swap: %d, %d\n", a, b) // 结果显示已交换

同理，传递给函数的数组也是按值拷贝。若要在函数内修改数组内容，同样受限于此规则。

指针传递：实现外部数据修改

如果需要在函数内部改变外部变量的值，必须传入变量地址并使用指针类型接收。

func main() {
    num1, num2 := 1, 2
    Swap(&num1, &num2)
    fmt.Printf("main: %d, %d\n", num1, num2) // 结果: 2, 1
}

func Swap(a *int, b *int) {
    *a, *b = *b, *a // 解引用并修改内存指向的值
}

函数即类型：高阶应用

在Go中，函数也是一种数据类型，这赋予了它极大的灵活性。

创建函数变量

可以将已有函数赋值给变量，并通过变量进行调用。

hl := Hello
hl("cmy")

作为参数传递（回调函数）

可以定义一个接受函数作为参数的函数。注意定义类型时要匹配签名。

func Print(name string, f func(string)) {
    f(name)
}

返回函数

函数可以返回另一个函数（通常是匿名函数），这在工厂模式或策略模式中非常有用。

func Print() func() {
    return func() {
        fmt.Println("Hello，World！")
    }
}

基于函数定义自定义类型

为了代码可读性，可以为特定的函数签名创建自定义类型别名，使其更易于维护。

type AddHandleFunc func(num1, num2 int) int

func GetSum(num1, num2 int, handle AddHandleFunc) int {
    return handle(num1, num2)
}