异常教程

Go 语言向函数传递数组（保姆级教程）

更新时间:

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战 / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

截止目前， 星球 内专栏累计输出 90w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 3100+ 小伙伴加入学习 ，欢迎点击围观

前言

在编程中，函数是组织代码的核心模块，而参数传递则是函数与外部交互的关键机制。对于 Go 语言开发者而言，理解如何向函数传递数组这一基础数据结构，不仅能提升代码的可读性和复用性，还能避免因数据类型特性导致的逻辑错误。本文将从数组的基础概念出发，逐步解析 Go 语言中向函数传递数组的多种方法，并通过具体案例帮助读者掌握其实用技巧。

数组的基础知识：定义与特性

数组的定义与固定长度特性

Go 语言中的数组（Array）是一种固定长度的有序数据集合。其定义格式为：

var arrayName [length]dataType

例如，定义一个包含 5 个整数的数组：

var numbers [5]int

数组的长度一旦确定便无法更改，这一特性被称为 固定长度特性。这与 Go 中的切片（Slice）不同，后者可以动态调整大小。

形象比喻：
可以将数组想象为一个固定数量的抽屉柜，每个抽屉的位置和数量都预先固定；而切片则像一个可伸缩的收纳盒，能根据需求增减容量。

数组与切片的区别

特性数组（Array）切片（Slice）
长度固定动态
内存分配连续内存空间通过指针引用底层数组
传递参数值传递（复制整个数组）引用传递（共享底层数据）

向函数传递数组：核心方法与注意事项

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

Go 语言的函数参数传递采用 值传递（Pass-by-Value） 机制。对于数组而言，传递时会复制整个数组的值到函数内部。

示例代码：通过值传递修改数组

func modifyArray(arr [3]int) {  
    arr[0] = 100  
}  

func main() {  
    original := [3]int{1, 2, 3}  
    modifyArray(original)  
    fmt.Println(original) // 输出：[1 2 3]  
}

关键点分析：

  • 函数 modifyArray 内部修改的 arr 是原始数组的副本，原始数组 original 未被改变。
  • 这种方式适用于 不需要修改原始数组 的场景，例如数据的只读计算。

方法二：通过指针传递数组

若希望函数能直接修改原始数组，可通过传递数组的指针（Pointer）实现。

示例代码：通过指针修改数组

func modifyArrayPointer(arr *[3]int) {  
    (*arr)[0] = 100 // 或 arr[0] = 100（Go 语言允许通过指针直接访问元素）  
}  

func main() {  
    original := [3]int{1, 2, 3}  
    modifyArrayPointer(&original)  
    fmt.Println(original) // 输出：[100 2 3]  
}

关键点分析：

  • 传递指针时，函数参数类型需声明为 *[n]dataType（例如 *[3]int）。
  • 通过指针访问元素时，可直接使用 arr[index]，无需显式解引用。

方法三：使用切片替代数组

由于数组的固定长度特性，直接传递数组在灵活性上存在局限。在多数实际场景中，推荐使用 切片（Slice） 替代数组。切片传递时共享底层数据，避免了复制的开销。

示例代码：通过切片传递

func modifySlice(slice []int) {  
    slice[0] = 100  
}  

func main() {  
    original := []int{1, 2, 3}  
    modifySlice(original)  
    fmt.Println(original) // 输出：[100 2 3]  
}

关键点分析：

  • 切片传递时，函数内部对元素的修改会直接反映到原始数据上。
  • 切片的灵活性使其更适合动态数据处理，但需注意内存安全和并发访问问题。

传递数组的注意事项

注意点 1：值传递的内存开销

当传递大型数组时，值传递会复制整个数组内容，可能导致性能下降。例如：

func processLargeArray(arr [10000]int) {  
    // ...  
}

若 arr 包含 10,000 个元素，每次调用函数都会复制这些数据，这在内存和时间上均不高效。此时应优先考虑指针或切片。

注意点 2：数组类型严格匹配

Go 语言的数组类型严格依赖长度和元素类型。例如：

var arr1 [2]int  
var arr2 [3]int  

func process(arr [2]int) {}  
process(arr2) // 编译报错：类型不匹配

若需处理不同长度的数组，建议改用切片或泛型（Go 1.18+）。

注意点 3：多维数组的传递

对于多维数组（如 [3][3]int），传递方式与一维数组一致，但需注意嵌套结构的引用问题。例如：

func modify2DArray(arr *[3][3]int) {  
    arr[0][0] = 999  
}  

func main() {  
    grid := [3][3]int{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}  
    modify2DArray(&grid)  
    fmt.Println(grid[0][0]) // 输出：999  
}

实际案例：统计数组元素的平均值

场景描述

假设需要编写一个函数，计算整数数组的平均值，并返回结果。

方法 1：通过值传递

func average(arr [5]int) float64 {  
    sum := 0  
    for _, num := range arr {  
        sum += num  
    }  
    return float64(sum) / float64(len(arr))  
}  

func main() {  
    data := [5]int{10, 20, 30, 40, 50}  
    fmt.Println(average(data)) // 输出：30  
}

方法 2：使用切片增强灵活性

func averageSlice(slice []int) float64 {  
    if len(slice) == 0 {  
        return 0  
    }  
    sum := 0  
    for _, num := range slice {  
        sum += num  
    }  
    return float64(sum) / float64(len(slice))  
}  

func main() {  
    data := []int{10, 20, 30, 40, 50, 60}  
    fmt.Println(averageSlice(data)) // 输出：35  
}

对比分析：

  • 方法 1 固定数组长度为 5，无法适应动态数据；
  • 方法 2 使用切片，可处理任意长度的输入，更具通用性。

进阶技巧：函数参数的类型推导与泛型

技巧 1：通过 ... 语法传递可变参数

Go 语言支持通过 ... 语法将多个元素打包为切片传递。例如：

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

func main() {  
    fmt.Println(sum(1, 2, 3, 4, 5)) // 输出：15  
}

此语法内部会将参数转换为切片，本质是传递一个隐式切片。

技巧 2：泛型的初步应用（Go 1.18+）

Go 1.18 引入的泛型可进一步增强数组/切片处理的通用性。例如：

func averageGeneric[T numeric](slice []T) float64 {  
    sum := T(0)  
    for _, num := range slice {  
        sum += num  
    }  
    return float64(sum) / float64(len(slice))  
}

（注：需定义 numeric 约束以确保类型支持加法和转换）

结论

通过本文的讲解，读者应能掌握 Go 语言向函数传递数组的三种核心方法：值传递、指针传递和切片传递。关键要点总结如下：

  1. 值传递适用于无需修改原始数据的场景，但需注意内存开销；
  2. 指针传递允许修改原始数组，但需显式声明指针类型；
  3. 切片是更灵活的选择，通过共享底层数据实现高效操作；
  4. 实际开发中，切片的灵活性和泛型的支持使其成为大多数场景的首选。

掌握这些技巧后，开发者能更高效地编写结构清晰、性能优化的 Go 代码，同时避免因类型特性导致的常见错误。希望本文能为 Go 语言学习者提供实用参考，助力代码质量的提升。

最新发布

查看更多文章