Go语言数组与切片详解：定义、初始化及底层内存机制

一、数组的基础与操作

数组是Go语言中相同类型元素的集合，元素在内存中连续存储。其核心特征在于类型一致且大小在定义阶段确定，不可更改。由于数组属于值类型，函数传参时会进行完整的拷贝。

第1步：数组的定义与初始化

可以通过指定长度和类型声明空数组，或直接初始化。推荐在不确定具体数量时使用省略号...让编译器推断长度。

// 定义大小为3的字符串和数字数组
var names [3]string
var ages [3]int8
fmt.Println(names, ages) // 输出：[  ] [0 0 0]

// 使用省略号自动推断长度
ages := [...]int{1, 2, 3, 4}
fmt.Println(ages) // 输出：[1 2 3 4]

也可通过索引直接指定位置初始化，未指定的位置填充零值：

// 在索引5和7处赋值
var ages [10]int = [10]int{5: 55, 7: 77}
fmt.Println(ages) // 输出：[0 0 0 0 0 55 0 77 0 0]

第2步：理解数组的长度固定性与类型关联

数组的大小是其类型的一部分，因此不同大小的数组被视为不同类型，不能相互赋值。获取长度使用len()函数，且长度在运行期不可变。

var a [2]int = [2]int{1, 2}
var b [3]int = [3]int{1, 2, 3}

b = a // 报错：cannot use a (type [2]int) as type [3]int in assignment
fmt.Println(len(a)) // 输出：2

第3步：遍历数组的多种方式

可以使用标准for循环结合索引，或使用range关键字。Range不仅返回索引，还可直接获取值，适合只需数据无需下标的场景。

arr := [...]int{7, 6, 5, 4}

// 仅取值，忽略索引
for _, value := range arr {
    fmt.Println(value)
}

// 二维数组遍历示例
matrix := [3][3]int{{1}, {2, 3, 4}, {5, 6}}
for _, row := range matrix {
    for _, val := range row {
        fmt.Print(val, " ")
    }
}

第4步：数组作为值类型的传递特性

因为数组是值类型，传入函数时会复制一份副本。修改函数内的数组不会影响原数组。若需修改，应传递指针或改用切片。

func modify(arr [2]int) {
    arr[0] = 99
    fmt.Println("Func inside:", arr) // 输出：[99 2]
}

a := [2]int{1, 2}
modify(a)
fmt.Println("Original:", a) // 输出：[1 2]，未被修改

二、切片的灵活应用与底层机制

切片（Slice）并非动态数组，而是对现有数组片段的轻量级描述结构（Header）。它包含指向底层数组的指针、长度（Len）和容量（Cap）。切片本身不拥有数据，仅引用数组。

第1步：创建与截取切片

通过数组的下标操作[low:high]生成切片。当只写a[:] 时，表示从开头到结尾。切片的类型显示为不带长度的方括号，如[]int。

var arr [10]int = [10]int{9, 8, 7, 6, 5, 4, 3, 2, 1, 0}

// 截取部分元素
slice := arr[3:6]
fmt.Println(slice)      // 输出：[6 5 4]
fmt.Printf("%T", slice) // 输出：[]int

// 查看长度和容量
// 长度：6-3=3
// 容量：从索引3到数组末尾的元素个数，即10-3=7
fmt.Println(len(slice), cap(slice)) // 输出：3 7

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

由于切片引用底层数组，修改切片的内容会直接影响原数组，反之亦然。这是理解Go内存管理的关键点。

var arr [10]int = [10]int{1, 2, 3, 4, 5}
slice := arr[1:3] // 引用 arr[1], arr[2]

slice[0] = 99     // 修改切片
fmt.Println(arr)   // 输出：[1 99 3 4 5]，数组同步变化

当多个切片来自同一数组的不同重叠区间时，它们的改动也会互相影响：

b := arr[3:5] // [4, 5]
c := arr[4:6] // [5, ...]
b[1] = 555
fmt.Println(c) // [555, ...]，c的第一个元素随之改变

第3步：Append操作与容量扩容机制

使用append向切片追加元素时，如果剩余容量不足，Go会分配一块更大的新数组，将旧数据拷贝过去，并让切片指向新数组。此时，原数组与新切片不再关联。

base := [10]int{9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
s := base[6:8] // 长度为2，容量为4 (从索引6到末尾)

s = append(s, 11) // 容量足够，直接在原数组追加
fmt.Println(base) // [9 8 7 6 5 4 3 2 11 0]

// 继续追加直到超出当前容量4
s = append(s, 22, 33)
// 触发扩容：重新分配数组，拷贝数据
// 此时 s 指向新内存，base 不变
s[0] = 99
fmt.Println(base) // [9 8 7 6 5 4 3 2 11 0] (未变)
fmt.Println(s)    // [22 33 11 99 ...] (包含新值及被修改的值)

以上就是Go语言数组与切片的详细内容，更多关于Go语言进阶技巧的资料请关注本站其它相关文章！