Go数组

Go数组长度固定，元素类型相同，是复合数据类型的基础。

数组声明与初始化

基本语法

// 声明数组（零值初始化）
var arr [5]int  // [0, 0, 0, 0, 0]

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

// 短声明
arr := [5]int{1, 2, 3, 4, 5}

部分初始化

// 部分元素初始化
arr := [5]int{1, 2}  // [1, 2, 0, 0, 0]

// 指定索引初始化
arr := [5]int{0: 1, 3: 10}  // [1, 0, 0, 10, 0]

自动推断长度

// 让编译器推断长度
arr := [...]int{1, 2, 3}  // [3]int

arr := [...]int{0: 1, 5: 6}  // [6]int

数组访问与修改

索引访问

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

// 读取元素
fmt.Println(arr[0])  // 1
fmt.Println(arr[4])  // 5

// 修改元素
arr[0] = 10
fmt.Println(arr[0])  // 10

// 索引越界
fmt.Println(arr[5])  // panic! 索引超出范围

数组长度

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

len := len(arr)  // 5
fmt.Println(len)

数组遍历

for循环遍历

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

// 普通for循环
for i := 0; i < len(arr); i++ {
    fmt.Println(arr[i])
}

for range遍历

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

// range遍历
for index, value := range arr {
    fmt.Println(index, value)
}

// 只获取值
for _, value := range arr {
    fmt.Println(value)
}

// 只获取索引
for index := range arr {
    fmt.Println(index)
}

数组特性

长度固定

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

// 不能添加元素
arr[5] = 6  // panic!

// [5]int和[3]int是不同类型
var a [5]int
var b [3]int
a = b  // 编译错误！类型不同

数组长度是类型的一部分，[5]int和[3]int是不同类型。

值类型

// 数组是值类型，赋值是复制
arr1 := [3]int{1, 2, 3}
arr2 := arr1  // 复制整个数组

arr2[0] = 10
fmt.Println(arr1[0])  // 1（arr1不变）
fmt.Println(arr2[0])  // 10

数组赋值、传参都是完整复制，修改不影响原数组。

多维数组

定义与初始化

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

matrix := [3][4]int{
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12},
}

// 访问元素
fmt.Println(matrix[0][1])  // 2

// 部分初始化
matrix := [3][4]int{
    {1, 2},
    {5, 6, 7},
}

遍历多维数组

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

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

数组vs slice

要点总结

• 数组长度固定，元素类型相同
• 长度是类型一部分，[5]int≠[3]int
• 数组是值类型，赋值复制整个数组
• 部分初始化其他元素零值
• [...]让编译器推断长度
• 索引访问，越界panic
• range遍历获取索引和值
• 数组不适合动态数据，用slice
• 函数传数组复制，传slice引用