一、Go基础知识10、数组详解

Go语言中，数组是具有固定长度且元素类型相同的数据结构。

一、数组的基本用法

• 声明数组的语法如下：

var arr [5]int   // 创建一个包含5个整数的数组

• 数组的长度是数组类型的一部分，因此[5]int和[10]int是两种不同的数组类型。
• 数组的索引是从0开始的。

二、数组的初始化

• 可以使用数组字面值来初始化数组。

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

• 如果未指定数组长度，Go语言会根据提供的元素数量自动推断数组的长度。

arr := [...]int{1, 2, 3, 4, 5}  // 数组长度为5

三、多维数组

• Go语言支持多维数组，例如二维数组。

var matrix [3][3]int  // 3x3的二维数组

四、数组的基本用法

1、基本数组用法

package main

import "fmt"

func main() {
    // 声明并初始化数组
    arr := [5]int{1, 2, 3, 4, 5}

    // 访问数组元素
    fmt.Println("Array elements:")
    for i := 0; i < len(arr); i++ {
        fmt.Printf("%d ", arr[i])
    }

    // 修改数组元素
    arr[2] = 10
    fmt.Printf("\nUpdated array: %v\n", arr)
}

结果：

Array elements:
1 2 3 4 5 
Updated array: [1 2 10 4 5]

2、多维数组

package main

import "fmt"

func main() {
    // 初始化二维数组
    matrix := [3][3]int{
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9},
    }

    // 访问二维数组元素
    fmt.Println("Matrix elements:")
    for i := 0; i < 3; i++ {
        for j := 0; j < 3; j++ {
            fmt.Printf("%d ", matrix[i][j])
        }
        fmt.Println()
    }
}

结果：

Matrix elements:
1 2 3 
4 5 6 
7 8 9 

五、数组的奇特用法

在Go语言中，数组是一种固定长度、元素类型相同的数据结构。
虽然数组的长度是固定的，但是可以使用一些技巧和特性来展示一些有趣或奇特的用法。

1、隐式类型和初始化

在Go语言中，数组的长度是类型的一部分，但可以使用...让编译器根据提供的元素数量推断数组的长度。

package main

import "fmt"

func main() {
    // 隐式类型和初始化
    arr := [...]int{1, 2, 3, 4, 5}

    // 打印数组
    fmt.Println("Array elements:")
    for i := 0; i < len(arr); i++ {
        fmt.Printf("%d ", arr[i])
    }
}

结果：

Array elements:
1 2 3 4 5

2、多维数组的变种

Go语言支持多维数组，你可以创建不规则数组，即每一行的长度可以不同。

package main

import "fmt"

func main() {
    // 不规则数组
    irregularArray := [...][3]int{
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9, 10}, // 不规则，这一行长度为4
    }

    // 打印不规则数组
    fmt.Println("Irregular array elements:")
    for i := 0; i < len(irregularArray); i++ {
        for j := 0; j < len(irregularArray[i]); j++ {
            fmt.Printf("%d ", irregularArray[i][j])
        }
        fmt.Println()
    }
}

结果：

Irregular array elements:
1 2 3 
4 5 6 
7 8 9 10 

3、数组作为函数参数

数组可以作为函数的参数传递。在传递数组时，实际上传递的是数组的副本，而不是原始数组。

package main

import "fmt"

// 函数接受数组作为参数
func doubleArray(arr [5]int) {
    for i := 0; i < len(arr); i++ {
        arr[i] *= 2
    }
}

func main() {
    // 数组作为函数参数
    arr := [...]int{1, 2, 3, 4, 5}

    fmt.Println("Original array:", arr)

    // 调用函数，修改数组
    doubleArray(arr)

    fmt.Println("Modified array:", arr)
}

结果：

Original array: [1 2 3 4 5]
Modified array: [1 2 3 4 5]

在这个例子中，虽然函数内部修改了数组，但因为是传值的方式传递，所以原始数组并未被修改。