Go语言数组与切片有何不同？

最近发现不少小伙伴都对Golang很感兴趣，所以今天继续给大家介绍Golang相关的知识，本文《Go语言数组与切片区别解析》主要内容涉及到等等知识点，希望能帮到你！当然如果阅读本文时存在不同想法，可以在评论中表达，但是请勿使用过激的措辞~

在Go语言中，数组（Array）和切片（Slice）是两种常用的复合数据类型，它们在声明、行为和内存管理上存在显著差异。许多初学者常常混淆这两种类型，尤其是在涉及赋值和函数参数传递时。本文旨在通过详细解释和示例代码，帮助读者彻底理解数组和切片的特性及其行为模式。

数组的特性与声明

Go语言中的数组是一种值类型，具有固定长度。一旦声明，其长度就不能改变。当一个数组被赋值给另一个数组，或者作为函数参数传递时，Go语言会创建一个完整的副本。这意味着对副本的任何修改都不会影响原始数组。

数组的声明方式有以下几种：

1. 指定长度并初始化：

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

2. 让编译器推断长度并初始化：

   arr2 := [...]int{1, 2, 3} // 编译器会根据初始化元素数量推断数组长度为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）。

当一个切片被赋值给另一个切片，或者作为函数参数传递时，复制的不是底层数据，而是切片头（包含指针、长度和容量）。这意味着，两个切片可能指向同一个底层数组，因此通过其中一个切片修改底层数据，会影响到另一个切片。

切片的声明和创建方式：

1. 字面量方式创建切片：

   slice1 := []int{1, 2, 3} // 创建一个长度为3的切片，并初始化，底层会自动创建一个匿名数组

2. 使用 make 函数创建切片：

   slice2 := make([]int, 3)     // 创建一个长度为3的切片，容量也为3，元素默认为零值
   slice3 := make([]int, 3, 5) // 创建一个长度为3，容量为5的切片，元素默认为零值

3. 从现有数组或切片派生：

   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 了？
}

代码分析：

1. arr := []int{1, 2, 3, 4, 5}： 这行代码创建的不是一个数组，而是一个切片。Go编译器会自动创建一个匿名的底层数组，然后 arr 这个切片会指向这个匿名数组，其长度为5，容量也为5。
2. arr2 := arr： 这行代码执行的是切片赋值操作。它不会复制底层数组。相反，它只是复制了 arr 的切片头（即指向底层匿名数组的指针、长度和容量）到 arr2。因此，此时 arr 和 arr2 都指向同一个底层数组。
3. shuffle(arr)： 当 arr 作为参数传递给 shuffle 函数时，Go语言同样会复制 arr 的切片头。shuffle 函数内部的 arr 参数和 main 函数中的 arr（以及 arr2）都指向同一个底层数组。因此，shuffle 函数对 arr（即其底层数组）的任何修改，都会反映在 main 函数中的 arr 和 arr2 上。
4. for _, i := range arr2 { fmt.Printf("%d ", i) }： 由于 arr 和 arr2 共享同一个底层数组，当 shuffle 函数修改了底层数组的元素顺序后，arr2 在遍历时自然会显示出被修改后的顺序。

总结与注意事项

• 数组是值类型，长度固定。 赋值和传参时会进行完整复制，互不影响。适用于数据量小、长度确定的场景。
• 切片是引用类型，长度可变。 赋值和传参时仅复制切片头，指向同一底层数组。对切片的修改会影响共享的底层数据。适用于需要动态增长或缩减的序列数据。
• “切片是引用类型”的准确理解： 虽然切片本身（切片头）是按值传递的，但它包含的指针指向的是共享的底层数据。因此，修改切片中的元素会影响到所有引用该底层数组的切片。
• 在Go语言中，除非明确声明为 [N]T 形式，否则 []T{...} 语法通常创建的是切片，而不是数组。

理解数组和切片的这些核心差异，是编写高效、正确Go程序的基础。在实际开发中，切片的使用频率远高于数组，但了解数组的特性有助于更好地理解切片的底层机制。

以上就是《Go语言数组与切片有何不同？》的详细内容，更多关于的资料请关注golang学习网公众号！