Go语言数组核心细节：len与cap、遍历、传参及实战

基础概念与长度容量

在Go语言中，数组是固定长度的同类型数据集合。理解其基本属性需要使用len（长度）和cap（容量）两个内置函数。对于普通数组，其长度和容量始终相等，且定义为编译期常量。

以下代码演示了定义一个长度为2的整型数组，并打印其长度和容量：

package main

func main() {
    a := [2]int{}
    println(len(a), cap(a)) 
}

运行结果显示均为2。由于未进行显式初始化，数组内的元素默认被零值化（整型为0）。需注意，虽然二维数组可以使用[...][3]int省略外层维度，但内层维度必须明确指定大小，不能使用省略号代替。

二维数组的遍历逻辑

处理二维数组时，通常采用嵌套的for range循环。外层循环提取每一行切片，内层循环遍历该行中的具体元素。这种结构是处理多维数据的通用模式。

package main
import (
    "fmt"
)
func main() {
    var f [2][3]int = [...][3]int{{1, 2, 3}, {7, 8, 9}}
    for k1, v1 := range f {
        for k2, v2 := range v1 {
            fmt.Printf("(%d,%d)=%d ", k1, k2, v2)
        }
        fmt.Println()
    }
}

示例中定义了2行3列的数组f。第一遍循环获取行索引k1和该行数组v1；第二遍循环获取列索引k2和对应的值v2。最终按坐标格式输出每个元素的值。

数组拷贝与传参机制

Go语言中数组是值类型。当数组作为函数参数传递时，默认发生的是值拷贝，即整个数组的内容会被复制到新内存中。若需在函数内修改原数组，应传递指向数组的指针。

package main
import "fmt"
func printArr(arr *[5]int) {
    arr[0] = 10
    for i, v := range arr {
        fmt.Println(i, v)
    }
}
func main() {
    var arr1 [5]int
    printArr(&arr1)
    fmt.Println(arr1)
    arr2 := [...]int{2, 4, 6, 8, 10}
    printArr(&arr2)
    fmt.Println(arr2)
}

上述代码中，printArr接收的是指向长度为5的整型数组的指针。在函数内部将第一个元素修改为10后，该修改会直接影响原数组。main函数中先调用未初始化的arr1，其首个元素变为10，其余为0，打印结果为[10 0 0 0 0]。随后调用已赋值的arr2，其首个元素同样被修改为10，结果变为[10 4 6 8 10]。这证明了指针传参与值传参的本质区别。

常见算法实战

第1步：计算数组所有元素之和

此场景涉及生成随机数据并求和，展示基本的线性遍历。

package main
import (
    "fmt"
    "math/rand"
    "time"
)
func sumArr(a [10]int) int {
    var sum int = 0
    for i := 0; i < len(a); i++ {
        sum += a[i]
    }
    return sum
}
func main() {
    rand.Seed(time.Now().Unix())
    var b [10]int
    for i := 0; i < len(b); i++ {
        b[i] = rand.Intn(1000)
    }
    sum := sumArr(b)
    fmt.Printf("sum=%d\n", sum)
}

sumArr函数通过索引遍历累加元素。在主函数中，利用rand包生成10个随机数填充数组，再传递给求和函数得到最终结果。

第2步：寻找满足条件的数组下标组合

针对“找出数组中和为给定值的两个元素的下标”这一经典问题，需采用双重循环进行全量比对。

package main
import "fmt"
func myTest(a [5]int, target int) {
    for i := 0; i < len(a); i++ {
        other := target - a[i]
        for j := i + 1; j < len(a); j++ {
            if a[j] == other {
                fmt.Printf("(%d,%d)\n", i, j)
            }
        }
    }
}
func main() {
    b := [5]int{1, 3, 5, 8, 7}
    myTest(b, 8)
}

逻辑上，外层循环固定第一个元素a[i]，计算所需的另一个数值other。内层循环从i+1开始查找是否存在该值。若找到则输出对应的两个索引。以数组{1, 3, 5, 8, 7}和目标值8为例，程序将输出符合条件的下标组合。

总结

掌握Go语言数组的与特性、嵌套遍历语法以及传参时的内存行为，是编写高效且正确的基础保障。结合具体的算法场景练习，能进一步加深对值类型机制的理解。

以上就是Go语言数组核心细节的详细内容，更多关于Go语言数组技巧的资料请关注本站其它相关文章！