深入理解Go语言中的数组与切片：类型、行为与实践

package main

import "fmt"

func modifyArray(arr [3]int) {
    arr[0] = 99 // 修改的是副本
    fmt.Println("函数内修改后的数组副本:", arr)
}

func main() {
    var arr1 [3]int = [3]int{1, 2, 3}
    fmt.Println("原始数组 arr1:", arr1)

    modifyArray(arr1) // 传递的是 arr1 的副本
    fmt.Println("函数调用后原始数组 arr1:", arr1) // 原始数组未被修改

    var arr2 [3]int
    arr2 = arr1 // 数组赋值是全量复制
    arr2[0] = 100
    fmt.Println("arr1 赋值给 arr2 后 arr1:", arr1)
    fmt.Println("arr2:", arr2)
}

原始数组 arr1: [1 2 3]
函数内修改后的数组副本: [99 2 3]
函数调用后原始数组 arr1: [1 2 3]
arr1 赋值给 arr2 后 arr1: [1 2 3]
arr2: [100 2 3]

package main

import "fmt"

func modifySlice(s []int) {
    s[0] = 99 // 修改的是底层数组
    fmt.Println("函数内修改后的切片:", s)
}

func main() {
    var s1 []int = []int{1, 2, 3} // 这是一个切片字面量
    fmt.Println("原始切片 s1:", s1)

    modifySlice(s1) // 传递的是切片头信息的副本，但指针指向同一底层数组
    fmt.Println("函数调用后原始切片 s1:", s1) // 原始切片被修改

    var s2 []int
    s2 = s1 // 切片赋值是头信息复制，共享底层数组
    s2[0] = 100
    fmt.Println("s1 赋值给 s2 后 s1:", s1)
    fmt.Println("s2:", s2)

    // 验证切片字面量与数组字面量的区别
    // var arr3 [3]int = {1, 2, 3} // 编译错误，需要完整声明
    var arr3 = [3]int{1, 2, 3} // 数组字面量
    fmt.Printf("arr3 类型: %T, 值: %v\n", arr3, arr3)

    var slc3 = []int{1, 2, 3} // 切片字面量
    fmt.Printf("slc3 类型: %T, 值: %v\n", slc3, slc3)
}

原始切片 s1: [1 2 3]
函数内修改后的切片: [99 2 3]
函数调用后原始切片 s1: [99 2 3]
s1 赋值给 s2 后 s1: [100 2 3]
s2: [100 2 3]
arr3 类型: [3]int, 值: [1 2 3]
slc3 类型: []int, 值: [1 2 3]

var av = []int{1,5,2,3,7}

fmt.Println(av)
sort.Ints(av)
fmt.Println(av)

func Ints(a []int)

package main

import (
    "fmt"
    "sort"
)

func main() {
    var fixedArray = [5]int{1, 5, 2, 3, 7}
    fmt.Println("原始数组:", fixedArray)

    // sort.Ints(fixedArray) // 编译错误: cannot use fixedArray (type [5]int) as type []int in argument to sort.Ints

    // 如果要对数组进行排序，需要先将其转换为切片
    sort.Ints(fixedArray[:]) // 将数组转换为切片，然后传递
    fmt.Println("排序后的数组 (通过切片操作):", fixedArray)
}

cannot use fixedArray (type [5]int) as type []int in argument to sort.Ints