Go语言函数核心用法详解：参数、返回值与闭包实战

概述

在Go语言中，函数是执行特定任务的基本代码块。与其他语言不同，Go将函数视为“一等公民”，支持将其作为参数传递、从函数返回或赋值给变量。理解函数的定义规则、参数传递机制及高阶用法，是编写清晰、高效Go代码的关键。

函数定义与基本语法

Go函数的定义以 func 关键字开头，后接函数名、括号内的参数列表以及可选的返回值类型。左大括号 { 必须与函数声明写在同一行，这是Go语言的强制规范。

基本结构如下：

func functionName(params) returnType {
    // 执行语句
}

根据需求，函数可以分为无参、有参、无返回值、多返回值等多种形态。例如，一个不带参数的空函数定义为 func add() {}，而接收整数并返回整数的加法函数则为 func add(a, b int) int { return a + b }。

第1步：掌握参数传递机制

Go语言中的参数传递严格遵循“值传递”原则，但可以通过指针实现类似其他语言的引用传递效果。

• 值传递： 复制实参的值传递给形参。修改形参不会影响实参。例如在 swap 函数中直接交换拷贝值：

func swap(x, y int) {
    var temp int
    temp = x
    x = y
    y = temp
    // 这里的修改仅在局部生效，外部a,b不变
}

• 指针传递（模拟引用）： 传递变量的地址，函数内通过解引用修改内存值，从而影响实参。

func swapPointer(x *int, y *int) {
    var temp int
    temp = *x      // 保存x指向的地址上的值
    *x = *y        // 将y指向的值赋给x指向的位置
    *y = temp      // 将原x的值赋给y指向的位置
}

第2步：使用可变参数

Go支持可变参数，允许函数接收零个或多个同类型参数。可变参数通常放在参数列表的最后，并使用 ... 类型标记。

func sum(numbers ...int) int {
    s := 0
    for _, num := range numbers {
        s += num
    }
    return s
}

注意：Go不支持默认参数值，需依赖可变参数或选项模式来实现灵活性。

第3步：函数作为参数（高阶函数）

函数可以像普通变量一样被传递和调用。这在构建通用算法（如排序、过滤）时非常有用。

// f 是一个函数类型，接收两个int，返回一个int
func applyFunc(a, b int, f func(int, int) int) int {
    return f(a, b)
}

// 使用示例
result := applyFunc(5, 3, add)

如果需要利用反射获取函数名等信息，可引入 reflect 和 runtime 包：

func getFuncName(op func(...int) int) string {
    p := reflect.ValueOf(op).Pointer()
    fn := runtime.FuncForPC(p)
    if fn != nil {
        return fn.Name()
    }
    return ""
}

返回值与匿名函数

多个返回值

Go函数最显著的特性之一是支持返回多个值。这在处理错误信息或计算结果时非常便捷。

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

调用时可以使用多个变量接收：sum, diff := eval(10, 5)。如果不需要某个返回值，可以使用空白标识符 _ 跳过：

q, _ := eval(2, 1) // q为3，差值被忽略

匿名函数与闭包

匿名函数是没有名称的函数定义，常用于一次性逻辑或闭包场景。

// 定义并立即调用
result := func(x, y int) int {
    return x + y
}(1, 2)

也可以将匿名函数赋值给变量，使其拥有名字以便复用：

add := func(x, y int) int {
    return x + y
}

方法附加到函数类型

可以为函数类型定义方法，使其具备面向对象的部分特性：

type GreetingFunc func(name string) string

func (g GreetingFunc) sayHello(name string) {
    fmt.Println(g(name))
}

关键注意事项

1. 作用域与导出： 若函数定义在不同包中，需使用 import 导入。函数首字母大写表示对外可见（Exported），小写则仅限包内访问。
2. 无重载与嵌套： Go不支持函数重载（同名不同参）和函数嵌套定义。所有函数必须在全局或另一个函数内部以匿名形式存在，但逻辑上不支持传统嵌套。
3. 左大括号位置： func 后的左大括号 { 绝不能另起一行，否则编译器会报错。
4. 参数本质： 无论是传值还是传指针，Go始终进行值拷贝。区别在于拷贝的是数据本身，还是数据的地址。

完整示例代码

以下代码整合了上述所有概念，可直接运行验证：

package main

import (
	"fmt"
	"reflect"
	"runtime"
)

// 基本加法
func add(a, b int) int {
	return a + b
}

// 指针交换
func swap(x *int, y *int) {
	temp := *x
	*x = *y
	*y = temp
}

// 可变参数求和
func sum(nums ...int) int {
	s := 0
	for _, n := range nums {
		s += n
	}
	return s
}

// 函数作为参数
func applyFunc(a, b int, f func(int, int) int) int {
	return f(a, b)
}

// 反射获取函数名
func getFuncInfo(op func(...int) int, a, b int) (int, string) {
	p := reflect.ValueOf(op).Pointer()
	name := runtime.FuncForPC(p).Name()
	// 注意：这里简单适配sum签名
	return op(a, b), name
}

// 多返回值
func eval(a, b int) (int, int) {
	return a + b, a - b
}

func main() {
	a, b := 20, 5

	// 1. 基本调用
	fmt.Println("Sum:", add(a, b))

	// 2. 指针交换
	swap(&a, &b)
	fmt.Printf("After Swap: a=%d, b=%d\n", a, b)

	// 3. 可变参数
	fmt.Println("Var Sum:", sum(a, b, 10, 20))

	// 4. 函数作为参数
	fmt.Println("Applied:", applyFunc(a, b, add))

	// 5. 反射与信息
	numVal, funcName := getFuncInfo(sum, a, b)
	fmt.Printf("Reflect Value: %d, Func Name: %s\n", numVal, funcName)

	// 6. 多返回值与忽略
	q, _ := eval(a, b)
	fmt.Printf("Eval Result (sum only): %d\n", q)

	// 7. 匿名函数自调用
	inlineResult := func(x, y int) int { return x * y }(4, 5)
	fmt.Println("Inline Product:", inlineResult)
}

以上就是Go语言函数基本用法及示例详解的详细内容，更多关于Go语言函数的资料请关注本站其它相关文章！