Go语言数组与切片区别详解

数组（Arrays）的特性与使用

在Go语言中，数组是一种具有固定长度的同类型元素序列。数组是值类型，这意味着当一个数组被赋值给另一个数组变量，或者作为参数传递给函数时，会发生一次完整的元素复制。每个数组变量都拥有其独立的数据副本。

数组的声明与初始化：

数组的长度是其类型的一部分，一旦声明便不可改变。

// 声明一个长度为3的整型数组，并初始化
arr1 := [3]int{1, 2, 3} 

// 声明一个数组，长度由初始化时的元素数量决定
arr2 := [...]int{1, 2, 3} // 等同于 [3]int{1, 2, 3}

// 声明一个长度为3的整型数组，元素默认为零值（int类型为0）
var arr3 [3]int 

当进行数组赋值时，例如 arrB = arrA，arrB 会获得 arrA 的所有元素的一个全新副本。同样，将数组作为函数参数传递时，函数内部操作的是数组的副本，不会影响到原始数组。

切片（Slices）的特性与使用

与数组不同，切片是Go语言中更常用、更灵活的数据结构，用于表示同类型元素的动态序列。切片是对底层数组的一个引用。它包含三个核心组件：一个指向底层数组的指针、切片的长度（len）和切片的容量（cap）。

切片的声明与初始化：

切片可以通过多种方式创建，包括字面量、make 函数或从现有数组/切片中截取。

// 通过字面量创建切片，Go会为其创建匿名的底层数组
slice1 := []int{1, 2, 3} 

// 使用 make 函数创建切片，指定长度（len）
// 容量（cap）默认为长度，元素初始化为零值
slice2 := make([]int, 3) // 等同于 []int{0, 0, 0}

// 使用 make 函数创建切片，同时指定长度和容量
// 长度为3，容量为5，前3个元素初始化为零值
slice3 := make([]int, 3, 5) 

切片的引用行为：

切片是引用类型。这意味着当一个切片被赋值给另一个切片变量时（例如 sliceB = sliceA），复制的不是底层数组的数据，而是切片头（即指针、长度和容量）。因此，sliceA 和 sliceB 会指向同一个底层数组。对其中任何一个切片进行的修改（例如通过索引赋值），都会反映在另一个切片上，因为它们操作的是同一块内存区域。

同样，当切片作为函数参数传递时，函数接收的是切片头的一个副本。这个副本仍然指向与原始切片相同的底层数组。因此，函数内部对切片元素的修改会直接影响到函数外部的原始数据。

示例代码分析

让我们回顾并分析原始问题中的代码，以理解为何 arr2 会被 shuffle 函数修改：

package main

import (
    "fmt"
    "math/rand" // 注意：原代码使用 "rand"，Go 1.x 后推荐使用 "math/rand"
    "time"
)

func shuffle(arr []int) { // arr 是一个切片
    rand.Seed(time.Now().UnixNano()) // 推荐使用 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} // 声明并初始化了一个切片，而非数组
    arr2 := arr                 // arr2 复制了 arr 的切片头，两者指向同一底层数组

    shuffle(arr) // shuffle 函数接收 arr 的切片头副本，该副本仍指向同一底层数组

    for _, i := range arr2 {
        fmt.Printf("%d ", i)
    }
    fmt.Println() // 添加换行，美化输出
}

代码执行流程解释：

1. arr := []int{1, 2, 3, 4, 5}：这一行代码创建了一个切片。Go编译器会为此切片在内存中分配一个匿名的底层数组，并让 arr 这个切片变量指向它。
2. arr2 := arr：这一行是关键。它并没有复制底层数组的数据。相反，它复制了 arr 的切片头（即指向底层数组的指针、长度和容量）。因此，现在 arr 和 arr2 都指向并操作着内存中的同一个 int{1, 2, 3, 4, 5} 数组。
3. shuffle(arr)：当 arr 作为参数传递给 shuffle 函数时，shuffle 函数内部的 arr 参数变量也接收到了一个切片头副本。这个副本同样指向了原始的底层数组。
4. 在 shuffle 函数内部，arr[i], arr[j] = arr[j], arr[i] 这样的操作直接修改了底层数组的元素。
5. 函数 shuffle 执行完毕后，由于 arr 和 arr2 共享同一个底层数组，因此 main 函数中 arr2 的内容也随之改变，显示出被打乱后的序列。

总结与注意事项

• 数组是值类型，切片是引用类型。 这是理解它们行为差异的根本。
• 数组长度固定，切片长度可变。 切片提供了更灵活的数据结构，也是Go语言中处理动态序列的首选。
• 当需要传递数组的副本时，直接传递数组即可。
• 当需要传递切片并允许函数修改其底层数据时，直接传递切片即可。
• 如果需要创建切片的一个独立副本（即复制底层数据），可以使用内置的 copy() 函数：

  originalSlice := []int{1, 2, 3}
  copiedSlice := make([]int, len(originalSlice))
  copy(copiedSlice, originalSlice) // 将 originalSlice 的元素复制到 copiedSlice

• 在Go 1.x 及更高版本中，生成随机数推荐使用 math/rand 包，并使用 time.Now().UnixNano() 作为随机数种子，以获得更好的随机性。同时，rand.Intn(n) 返回的是 [0, n) 区间的随机数，在洗牌算法中，rand.Intn(i + 1) 才能正确覆盖 [0, i] 的范围。

理解数组与切片之间的细微但关键的区别，是编写高效、正确Go程序的基础。在大多数场景下，切片因其灵活性和引用特性而成为更优的选择。