在 Go 语言（Golang）中，数组（Array） 是一种固定长度的数据结构，它存储类型相同的元素。数组的长度在定义时就确定，无法改变。以下是 Go 语言中数组的基本用法和特点：

1.数组声明与初始化

(1) 基本声明

var arr [5]int  // 声明一个包含 5 个整数的数组，默认值为 0

(2) 直接初始化

arr := [5]int{1, 2, 3, 4, 5}  // 声明并初始化

(3) 省略长度（自动推导）

arr := [...]int{1, 2, 3, 4, 5}  // Go 自动推导数组长度

(4) 指定索引初始化

arr := [5]int{1: 10, 3: 20}  // 仅初始化索引 1 和 3，其余默认为 0
fmt.Println(arr)  // 输出: [0 10 0 20 0]

2.访问数组元素

arr := [3]int{10, 20, 30}
fmt.Println(arr[0])  // 访问第一个元素
arr[1] = 50          // 修改第二个元素
fmt.Println(arr)     // 输出: [10 50 30]

3.数组的长度

使用 len() 获取数组长度：

arr := [5]int{1, 2, 3, 4, 5}
fmt.Println(len(arr))  // 输出: 5

4.遍历数组

(1) 传统for循环

arr := [3]int{10, 20, 30}
for i := 0; i < len(arr); i++ {
    fmt.Println(arr[i])
}

(2) 使用range遍历

arr := [3]int{10, 20, 30}
for index, value := range arr {
    fmt.Printf("索引 %d: 值 %d\n", index, value)
}

5.数组是值类型

在 Go 语言中，数组是 值类型，意味着赋值或传递时，会 复制整个数组，而不是传递引用：

func modifyArray(arr [3]int) {
    arr[0] = 100  // 仅修改副本
}

func main() {
    a := [3]int{1, 2, 3}
    modifyArray(a)
    fmt.Println(a)  // 输出: [1 2 3]，原数组未改变
}

如果想要修改原数组，可以使用 指针：

func modifyArray(arr *[3]int) {
    arr[0] = 100  // 修改原数组
}

func main() {
    a := [3]int{1, 2, 3}
    modifyArray(&a)
    fmt.Println(a)  // 输出: [100 2 3]
}

6.多维数组

(1) 声明与初始化

var matrix [2][3]int  // 2 行 3 列的二维数组

matrix := [2][3]int{
    {1, 2, 3},
    {4, 5, 6},
}

(2) 访问多维数组

fmt.Println(matrix[0][1])  // 访问第一行第二个元素（输出: 2）

(3) 遍历多维数组

for i := 0; i < len(matrix); i++ {
    for j := 0; j < len(matrix[i]); j++ {
        fmt.Printf("%d ", matrix[i][j])
    }
    fmt.Println()
}

7.数组 vs 切片（slice）

Go 语言的 数组 长度固定，而 切片（slice） 是动态的、可变的，更常用。与数组不同，切片是 引用类型，共享底层数据：

arr := [5]int{1, 2, 3, 4, 5}
slice := arr[1:4]  // 创建切片 [2 3 4]
fmt.Println(slice)

如果需要灵活的数据结构，通常使用切片而不是数组。

总结

• 数组长度固定，声明后不可更改。
• 数组是值类型，赋值和函数传递时会复制整个数组。
• 可以使用 for 或 range 遍历数组。
• 多维数组可以嵌套，但不如切片灵活。
• Go 语言更推荐使用 切片（slice） 代替数组。

适用于：

• 固定大小的数据存储（如棋盘、矩阵）。
• 需要避免额外的切片开销的高性能场景。

如果你的数据长度是动态的，建议使用 切片 代替数组！