Go 语言函数全解析：从基础定义到高级特性

进阶调用方式

函数嵌套调用

函数嵌套调用指在一个函数内部调用另一个函数，这是构建模块化逻辑的基础。

func Test1(num1 int, num2 int) {
	fmt.Println("两数之和：", num1+num2)
}

func Test2(a int, b int) {
	Test1(a, b) // 调用 Test1 函数
}

func main() {
	Test2(1, 2) // 输出：3
}

不定参数函数

Go 语言支持不定参数（可变参数），通过 参数名...类型 的形式定义，不定参数在函数内部会被视为切片处理。

基础不定参数使用

// 接收任意数量的 int 类型参数
func Test3(args ...int) {
	for _, data := range args {
		fmt.Println(data)
	}
}

func main() {
	Test3(3, 5, 9) // 依次输出 3、5、9
}

不定参数的传递

若需将一个函数的不定参数传递给另一个函数，需使用 参数名... 的形式展开传递，否则会被当作单个切片参数传入。

func Test4(args ...int) {
	for _, data := range args {
		fmt.Println(data)
	}
}

func Test5(args ...int) {
	Test4(args...) // 展开不定参数传递给 Test4
}

func main() {
	Test5(3, 5, 9) // 输出：3、5、9
}

不定参数的部分传递

通过切片的方式，可将不定参数的部分数据传递给其他函数（如 args[:2] 表示取前 2 个元素）。

匿名函数与闭包

匿名函数

匿名函数是没有函数名的函数，常用于临时逻辑封装，可直接定义并调用，或赋值给变量后调用。这在回调函数或快速定义逻辑时非常有用。

func main() {
	var num int
	num = 9
	// 定义匿名函数并赋值给变量 f
	f := func() {
		num++
		fmt.Println("匿名函数：", num) // 输出 10
	}
	f() // 调用匿名函数
	fmt.Println("main 函数：", num) // 输出 10
}

闭包

闭包是有权访问另一个函数作用域中变量的函数。简单来说，就是在函数内部创建另一个函数，并且这个内部函数引用了外部函数的变量。Go 语言中，只有当匿名函数捕获了外部变量时，才构成真正的闭包。

反例（非闭包场景）：函数内的局部变量每次调用都会重新初始化。

func Test21() int {
	var x int
	x++
	return x
}

func main() {
	fmt.Println(Test21()) // 输出 1
	fmt.Println(Test21()) // 输出 1
	fmt.Println(Test21()) // 输出 1
}

正例（闭包场景）：通过闭包保留变量的状态。

func Test() func() int {
	var x int // 被闭包捕获的变量
	return func() int {
		x++
		return x
	}
}

func main() {
	f := Test()
	fmt.Println(f()) // 输出 1
	fmt.Println(f()) // 输出 2
	fmt.Println(f()) // 输出 3
}

匿名函数的重要特点在于它不关心这些捕获了的变量和常量是否已经超出了作用域，只要闭包还在使用它，这些变量就会一直存在内存中。

defer 延迟调用

基本概念

defer 是 Go 语言的延迟调用机制，其后的函数会在当前函数执行完毕后执行，且多个 defer 语句按后进先出（LIFO）的顺序执行。defer 常用于资源释放，比如关闭文件、释放锁等。

基础示例：

func main() {
	fmt.Println("1")
	defer fmt.Println("2") // 延迟执行
	fmt.Println("3")
}
// 输出顺序：1、3、2

特性说明

• defer 语句在定义时会立即计算参数值，但执行则延迟到函数结束。
• 多个 defer 按逆序执行，最后定义的 defer 最先执行。

递归函数

递归函数是指函数内部调用自身的函数，使用时必须定义递归终止条件，避免无限递归导致栈溢出。递归具有回溯性，适合处理树形结构或数学递推问题。

示例：递归打印数字并回溯

func Test(a int) {
	if a == 1 { // 递归终止条件
		fmt.Println("a=", a)
		return
	}
	Test(a - 1) // 调用自身
	fmt.Println("abc=", a)
}

func main() {
	Test(3)
	// 输出：
	// a= 1
	// abc= 2 回溯
	// abc= 3
}

经典应用包括递归实现阶乘、斐波那契数列等数学逻辑，或遍历树形结构。

函数与变量作用域

局部变量

定义在函数内部的变量为局部变量，仅在函数作用域内有效。不同函数可定义同名局部变量，互不影响。

全局变量

定义在函数外部的变量为全局变量，可在整个包内的所有函数中访问。若全局变量与局部变量同名，局部变量会覆盖全局变量。

var a int = 10 // 全局变量

func Test() {
	a = 5
	a++
	fmt.Println("Test 函数内 a：", a) // 输出：6
}

func main() {
	a = 9
	Test()
	fmt.Println("main 函数内 a：", a) // 输出：6
}

总结

Go 语言的函数体系兼具简洁性与灵活性：基础的函数定义与调用满足日常开发需求，嵌套调用与不定参数提升了代码的复用性，而匿名函数、闭包、defer 与递归则为高级编程提供了支撑。掌握这些特性，能让你写出更优雅、高效的 Go 语言代码。