Go语言数组与切片：创建、底层原理与操作详解

一、数组：定长序列的基础构建

在 Go 语言中，数组是长度固定的同类型元素序列。与其他大多数编程语言类似，其核心特征是长度在编译时确定且不可更改。正确理解数组的声明、初始化及其与切片的区别，是掌握 Go 数据结构的起点。

第1步：数组的声明与初始化

Go 支持多种数组声明方式，包括显式指定长度、使用 ... 省略号推断长度以及多维数组定义。

func arrayExample() {
    // 声明未赋值，自动初始化为零值
    var arr1 [5]int32
    
    // 显式指定类型和长度进行初始化
    var arr2 [5]int32 = [5]int32{1, 2, 3, 4, 5}
    
    // 简写形式，编译器自动推断类型
    arr3 := [5]int32{1, 2, 3, 4, 5}
    
    // 使用 ... 让编译器根据初始化列表计算长度
    arr4 := [...]int32{6, 7, 8, 9, 10}
    
    // 多维数组初始化：缺失部分会自动补零
    arr5 := [4][4]int32{{1}, {1, 2}, {1, 2, 3}}
}

上述代码展示了数组创建的灵活性。例如 arr4 中使用了 ...，Go 编译器会自动将其长度判定为 5。对于二维数组 arr5，未填充的部分会按数据类型填入零值（如 int32 为 0）。

第2步：获取数组的长度与容量

对于数组而言，长度（len）和容量（cap）始终相等，均表示元素的数量。

func lenCapExample() {
    arr := [5]int32{1, 2, 3, 4, 5}
    fmt.Println(len(arr)) // 输出: 5
    fmt.Println(cap(arr)) // 输出: 5
}

第3步：数组的遍历与访问

可以通过索引直接访问或配合 for range 循环进行遍历。注意在遍历时，若仅获取值而非索引，需谨慎处理变量作用域。

func traverseArray() {
    data := [5]string{"a", "b", "c", "d", "e"}
    
    // 使用 for range 同时获取索引和值
    for index, value := range data {
        fmt.Printf("Index: %d, Value: %s\n", index, value)
    }
}

二、切片（Slice）：灵活动态的数据结构

切片是对数组长度为段的轻量级抽象。本质上，它是一个指向底层数组的引用结构体，包含指向数组的指针、切片的长度（len）以及底层的容量（cap）。因为持有底层数组的引用，所以可以动态扩展，但也意味着多个切片可能共享同一块内存区域。

第1步：切片的创建方式

切片的创建主要有四种常见模式：

func createSlice() {
    // 1. 使用 make 函数，指定长度和可选的容量
    s1 := make([]int32, 5, 8) // 长度5，容量8
    
    // 2. 使用 make 函数，仅指定长度（默认容量等于长度）
    s2 := make([]int32, 9)
    
    // 3. 声明空切片
    s3 := []int32{}
    
    // 4. 直接初始化包含数据的切片
    s4 := []int32{1, 2, 3, 4, 5}
}

创建时需区分数组与切片语法的关键差异：数组在方括号内必须指定长度或 ...，而切片为空。

第2步：理解切片与底层数组的关系

这是 Go 切片最核心的概念。如果对切片进行子切片操作（Slicing），新切片仍指向原底层数组。因此，修改子切片的内容可能会影响原始数组或其他相关切片。

func sliceReference() {
    base := []string{"a", "b", "c", "d", "e"}
    
    // 创建一个子切片，引用 base 的一部分
    sub := base[2 : len(base)-1] // 对应元素 "c", "d"
    
    // 再次切片
    sub2 := base[:3] // 对应元素 "a", "b", "c"
    
    fmt.Println(base, sub, sub2) // 输出: [a b c d e] [c d] [a b c]
    
    // 修改子切片的元素
    sub2[2] = "changed"
    
    // 观察变化：由于共享底层数组，base 也会受影响
    fmt.Println(base, sub, sub2) // base 变为 [a b changed d e]
}

上例中，修改 sub2 的第三个元素，导致原始数组 base 的第三个元素也发生了改变，因为它们指向相同的内存地址。

第3步：切片的遍历与安全修改

遍历切片可使用 for range。需特别注意值传递与引用的区别：直接迭代值无法修改原切片内容，必须通过索引进行修改。

func modifySlice() {
    s := []string{"x", "y", "z"}
    
    // ❌ 错误方式：ele 是副本，修改它不影响原切片
    for _, ele := range s {
        ele = "modified"
    }
    
    // ✅ 正确方式：通过索引直接修改底层数组元素
    for i := range s {
        s[i] = "updated"
    }
}

第4步：追加 (Append) 与复制 (Copy)

append 函数用于向切片末尾添加元素。如果追加后超出当前容量，Go 会自动申请更大的底层数组并返回新切片；若未超出容量，则复用原底层数组。

func appendAndCopy() {
    src := []int32{1, 2, 3}
    
    // 追加元素
    dst := append(src, 4, 5)
    
    // 使用 copy 函数复制切片
    destArr := make([]int32, 5)
    n := copy(destArr, dst)
    // n 返回实际复制的元素个数
}

第5步：深入分析 append 的扩容行为

append 的行为取决于剩余容量。以下示例展示了当容量不足时触发扩容，而容量充足时直接修改底层数组的区别。

func deepDiveAppend() {
    fullSlice := []int32{1, 2, 3, 4, 5, 6}
    smallSlice := fullSlice[:2] // 长度2，容量6
    
    fmt.Println(fullSlice, smallSlice)
    
    // 追加元素使总长超过6，触发扩容
    result1 := append(smallSlice, 100, 200, 300)
    // 此时 smallSlice 不再受 fullSlice 影响，因为底层数组已换
    fmt.Println(fullSlice, result1)
    
    // 重置 smallSlice 以演示容量内追加
    smallSlice = fullSlice[:2] // 重新切片
    result2 := append(smallSlice, 999) // 容量足够，直接在原位覆盖
    
    // 注意：这会改变 original 数组的内容!
    fmt.Println(fullSlice, result2)
}

三、总结

数组适用于固定大小的场景，简单高效但缺乏灵活性；切片则是 Go 编程中最常用的数据结构，通过引用底层数组实现了动态长度。掌握切片的创建、共享底层内存的特性以及 append 的扩容逻辑，能够有效避免内存误改和资源浪费问题。 以上就是 GO 语言数组和切片实例详解的详细内容，更多关于 GO 语言程序设计资料请关注本站其它相关文章！