在go语言中，数组（array）和切片（slice）是两种常用的复合数据类型，它们在声明、行为和内存管理上存在显著差异。许多初学者常常混淆这两种类型，尤其是在涉及赋值和函数参数传递时。本文旨在通过详细解释和示例代码，帮助读者彻底理解数组和切片的特性及其行为模式。
数组的特性与声明
Go语言中的数组是一种值类型，具有固定长度。一旦声明，其长度就不能改变。当一个数组被赋值给另一个数组，或者作为函数参数传递时，Go语言会创建一个完整的副本。这意味着对副本的任何修改都不会影响原始数组。
数组的声明方式有以下几种：
-
指定长度并初始化：
arr1 := [3]int{1, 2, 3} // 声明一个长度为3的整型数组，并初始化 -
让编译器推断长度并初始化：
arr2 := [...]int{1, 2, 3} // 编译器会根据初始化元素数量推断数组长度为3 -
声明但未初始化（元素默认为零值）：
var arr3 [3]int // 声明一个长度为3的整型数组，元素默认为0
由于数组是值类型，以下代码的行为符合预期：
package main
import "fmt"
func modifyArray(a [3]int) {
a[0] = 100 // 修改的是副本
}
func main() {
myArray := [3]int{1, 2, 3}
anotherArray := myArray // 完整复制 myArray 的所有元素到 anotherArray
fmt.Println("Original myArray:", myArray) // 输出: Original myArray: [1 2 3]
fmt.Println("Original anotherArray:", anotherArray) // 输出: Original anotherArray: [1 2 3]
anotherArray[0] = 99 // 修改 anotherArray 不会影响 myArray
fmt.Println("myArray after modifying anotherArray:", myArray) // 输出: myArray after modifying anotherArray: [1 2 3]
fmt.Println("anotherArray after modification:", anotherArray) // 输出: anotherArray after modification: [99 2 3]
modifyArray(myArray) // 传递的是 myArray 的副本
fmt.Println("myArray after modifyArray function call:", myArray) // 输出: myArray after modifyArray function call: [1 2 3]
}切片的本质与操作
与数组不同，切片（Slice）是Go语言中一种引用类型，它提供了一种更强大、更灵活的数据结构。切片是对底层数组的一个引用，它本身不存储任何数据，而是描述了底层数组的一个连续片段。一个切片由三部分组成：指向底层数组的指针、切片的长度（length）和切片的容量（capacity）。
立即学习“go语言免费学习笔记（深入）”；
当一个切片被赋值给另一个切片，或者作为函数参数传递时，复制的不是底层数据，而是切片头（包含指针、长度和容量）。这意味着，两个切片可能指向同一个底层数组，因此通过其中一个切片修改底层数据，会影响到另一个切片。
切片的声明和创建方式：
-
字面量方式创建切片：
slice1 := []int{1, 2, 3} // 创建一个长度为3的切片，并初始化，底层会自动创建一个匿名数组 -
使用 make 函数创建切片：
slice2 := make([]int, 3) // 创建一个长度为3的切片，容量也为3，元素默认为零值 slice3 := make([]int, 3, 5) // 创建一个长度为3，容量为5的切片，元素默认为零值
-
从现有数组或切片派生：
arr := [5]int{1, 2, 3, 4, 5} slice4 := arr[0:3] // 从数组 arr 创建一个切片，包含 arr 的前3个元素
深入理解示例代码中的切片行为
现在，我们来分析原问题中提供的代码片段，解释为什么 arr2 会被 shuffle 函数修改：
package main
import (
"fmt"
"math/rand" // 推荐使用 math/rand
"time"
)
func shuffle(arr []int) { // 注意：这里的 arr 是一个切片
rand.Seed(time.Now().UnixNano()) // 推荐使用 time.Now().UnixNano()
for i := len(arr) - 1; i > 0; i-- {
j := rand.Intn(i + 1) // rand.Intn(n) 返回 [0, n)
arr[i], arr[j] = arr[j], arr[i]
}
}
func main() {
arr := []int{1, 2, 3, 4, 5} // 1. 这里创建的是一个切片，而不是数组
arr2 := arr // 2. 将 arr 赋值给 arr2
fmt.Println("Original arr:", arr)
fmt.Println("Original arr2:", arr2)
shuffle(arr) // 3. 将切片 arr 传递给 shuffle 函数
fmt.Println("Shuffled arr:", arr)
fmt.Println("Shuffled arr2:", arr2) // 4. 为什么 arr2 也被 shuffle 了？
}代码分析：
- arr := []int{1, 2, 3, 4, 5}： 这行代码创建的不是一个数组，而是一个切片。Go编译器会自动创建一个匿名的底层数组，然后 arr 这个切片会指向这个匿名数组，其长度为5，容量也为5。
- arr2 := arr： 这行代码执行的是切片赋值操作。它不会复制底层数组。相反，它只是复制了 arr 的切片头（即指向底层匿名数组的指针、长度和容量）到 arr2。因此，此时 arr 和 arr2 都指向同一个底层数组。
- shuffle(arr)： 当 arr 作为参数传递给 shuffle 函数时，Go语言同样会复制 arr 的切片头。shuffle 函数内部的 arr 参数和 main 函数中的 arr（以及 arr2）都指向同一个底层数组。因此，shuffle 函数对 arr（即其底层数组）的任何修改，都会反映在 main 函数中的 arr 和 arr2 上。
- for _, i := range arr2 { fmt.Printf("%d ", i) }： 由于 arr 和 arr2 共享同一个底层数组，当 shuffle 函数修改了底层数组的元素顺序后，arr2 在遍历时自然会显示出被修改后的顺序。
总结与注意事项
- 数组是值类型，长度固定。 赋值和传参时会进行完整复制，互不影响。适用于数据量小、长度确定的场景。
- 切片是引用类型，长度可变。 赋值和传参时仅复制切片头，指向同一底层数组。对切片的修改会影响共享的底层数据。适用于需要动态增长或缩减的序列数据。
- “切片是引用类型”的准确理解： 虽然切片本身（切片头）是按值传递的，但它包含的指针指向的是共享的底层数据。因此，修改切片中的元素会影响到所有引用该底层数组的切片。
- 在Go语言中，除非明确声明为 [N]T 形式，否则 []T{...} 语法通常创建的是切片，而不是数组。
理解数组和切片的这些核心差异，是编写高效、正确Go程序的基础。在实际开发中，切片的使用频率远高于数组，但了解数组的特性有助于更好地理解切片的底层机制。
