Go 语言向函数传递数组（详细教程）

Go 语言向函数传递数组：从基础到进阶的完整指南

在 Go 语言中，数组是基础数据结构之一，而如何将数组传递给函数，是每个开发者在实际编码中都会遇到的问题。很多人初学时会误以为数组传递和指针传递是同一件事，或者搞不清值传递和引用传递的区别。今天我们就来深入剖析 Go 语言向函数传递数组的底层机制，用真实案例带你彻底搞懂。

为什么数组传递容易出错？

想象一下，你有一个装满水果的篮子（数组），现在要把它交给朋友（函数）。如果直接把整个篮子搬过去，那叫值传递；如果只给朋友一个“篮子在哪儿”的地址，那叫引用传递。在 Go 中，数组是值类型，所以当你把数组传给函数时，实际上是复制了一份完整的数组副本。

这听起来很合理，但问题来了：如果你传的是一个包含 1000 个元素的数组，复制一次就消耗 1000 倍内存，性能会严重下降。所以，Go 的设计者在语言层面做了巧妙处理：Go 语言向函数传递数组时，实际上是传值，但数组长度固定，因此性能开销可以预估。

但别急着下结论。我们来看代码。

创建数组与初始化

在 Go 中，数组的声明格式为：var 数组名 [长度]类型。长度在编译时就确定，不可更改。

// 声明一个长度为 5 的整型数组，所有元素初始为 0
var numbers [5]int

// 使用字面量初始化
scores := [3]int{85, 92, 78}

// 省略长度，由编译器自动推导
temps := [...]int{20, 22, 18, 25, 21}

// 打印数组内容
fmt.Println("scores:", scores)
fmt.Println("temps:", temps)

注释：[3]int{85, 92, 78} 是数组字面量写法，Go 会自动推断长度为 3。[...]int 是省略长度的语法，适合在初始化时使用。

Go 语言向函数传递数组的三种方式

我们通过三个示例来演示不同传递方式的差异。

方式一：直接传递数组（值传递）

func modifyArray(arr [3]int) {
    arr[0] = 100 // 修改副本，不影响原数组
    fmt.Println("函数内修改后:", arr)
}

func main() {
    data := [3]int{1, 2, 3}
    fmt.Println("调用前:", data)

    modifyArray(data) // 传的是副本

    fmt.Println("调用后:", data) // 原数组未改变
}

注释：modifyArray 接收的是 [3]int 类型的数组。由于 Go 中数组是值类型，data 会被完整复制一份传入函数。函数内部修改的是副本，原始数据不受影响。

方式二：传递数组指针（引用传递）

func modifyArrayPtr(arr *[3]int) {
    arr[0] = 100 // 修改原数组
    fmt.Println("指针函数内修改后:", arr)
}

func main() {
    data := [3]int{1, 2, 3}
    fmt.Println("调用前:", data)

    modifyArrayPtr(&data) // 传入地址

    fmt.Println("调用后:", data) // 原数组被修改
}

注释：&data 取地址，*[3]int 表示接收一个指向 [3]int 的指针。函数内部可以直接修改原始数据，实现“引用传递”。

方式三：使用切片（推荐方式）

func modifySlice(slice []int) {
    slice[0] = 100 // 修改底层数组
    fmt.Println("切片函数内修改后:", slice)
}

func main() {
    data := [3]int{1, 2, 3}
    fmt.Println("调用前:", data)

    // 将数组转为切片
    modifySlice(data[:])

    fmt.Println("调用后:", data) // 原数组被修改！
}

注释：data[:] 是将数组转为切片的语法。切片本身是一个结构体，包含指针、长度和容量。它不复制数据，只共享底层数组，因此修改切片会直接影响原数组。

三种方式对比表

注释：切片是 Go 中最常用的数组操作方式，因为它兼顾性能和灵活性。推荐在大多数场景中使用切片而非原始数组。

实际应用案例：统计学成绩分析

假设你是一名教育系统开发者，需要对班级成绩进行统计。数组长度固定（50人），但你希望在函数中修改数据并返回结果。

// 定义班级成绩数组
var classScores [50]float64

// 初始化成绩（模拟数据）
func initScores() {
    for i := 0; i < 50; i++ {
        classScores[i] = 60 + float64(i) * 0.5 // 从 60 分开始，逐步提高
    }
}

// 计算平均分（传数组副本）
func calculateAverage(arr [50]float64) float64 {
    total := 0.0
    for _, score := range arr {
        total += score
    }
    return total / float64(len(arr))
}

// 提升所有成绩 5 分（传指针）
func boostScores(arr *[50]float64) {
    for i := range *arr {
        (*arr)[i] += 5.0 // 通过指针修改原数组
    }
}

func main() {
    initScores()

    avg1 := calculateAverage(classScores)
    fmt.Printf("提升前平均分: %.2f\n", avg1)

    boostScores(&classScores) // 传地址

    avg2 := calculateAverage(classScores)
    fmt.Printf("提升后平均分: %.2f\n", avg2)
}

注释：calculateAverage 接收数组副本，确保原始数据安全；boostScores 传指针，实现对原始数据的修改。这种组合方式在实际项目中非常常见。

常见误区与最佳实践

误区 1：认为数组传递是引用传递

很多 Java 或 C++ 开发者会误以为 Go 中数组传递是引用，其实不然。Go 的数组是值类型，必须显式传地址才能实现引用语义。

误区 2：过度使用大数组传值

如果数组长度超过 1000，直接传值会带来性能问题。建议改用切片。

最佳实践建议：

• 小数组（< 100）：可直接传值，代码清晰
• 需要修改原数据：使用指针 *[N]T
• 大数组或动态长度：使用切片 []T
• 函数只读数据：传值或切片
• 函数需修改数据：传指针或切片

总结：掌握 Go 语言向函数传递数组的核心

今天我们一起深入学习了 Go 语言向函数传递数组的三种主要方式：值传递、指针传递和切片传递。通过实际代码对比，你已经能分辨它们在性能、安全性和灵活性上的差异。

记住：数组在 Go 中是值类型，传递时会复制完整数据。如果你希望函数修改原始数据，就必须使用指针或切片。在大多数实际项目中，推荐使用切片，它既高效又灵活。

最后提醒一句：别再把数组和切片混为一谈了。它们是不同概念，尽管切片底层基于数组。理解这一点，你对 Go 的内存模型和函数调用机制就会有更深的认识。

Go 语言向函数传递数组，看似简单，实则暗藏玄机。掌握它，是迈向 Go 高级开发的重要一步。