切換語言為:簡體

詳解Go語言中的陣列

  • 爱糖宝
  • 2024-10-22
  • 2044
  • 0
  • 0

基本概念

在 Go 語言中,陣列(Array)是一種固定長度的、相同型別的元素序列。陣列的長度在宣告時就已經確定,並且不能改變。陣列的每個元素可以透過索引訪問,索引從 0 開始。

陣列的宣告和初始化:

在 Go 語言中,陣列的宣告和初始化有多種方式,以下是幾種常見的方式:

1. 宣告並初始化陣列

方式一:使用 var 關鍵字宣告並初始化

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

方式二:使用短變數宣告並初始化

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

2. 宣告陣列但不初始化

var arr [5]int

這種方式宣告的陣列,所有元素會被初始化為該型別的零值(例如,int 型別的零值是 0)。

3. 使用省略號 ... 自動推斷陣列長度

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

這種方式會根據初始化列表中的元素個數自動推斷陣列的長度。

4. 部分初始化陣列

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

這種方式會初始化前兩個元素為 12,其餘元素會被初始化為零值。

5. 指定索引初始化陣列

css程式碼解讀複製程式碼arr := [5]int{0: 1, 4: 5}

這種方式會初始化索引為 0 的元素為 1,索引為 4 的元素為 5,其餘元素會被初始化為零值。

6. 多維陣列的宣告和初始化

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

多維陣列的宣告和初始化與一維陣列類似,只是巢狀了更多的維度。

示例程式碼:

package main

import "fmt"

func main() {
    // 方式一:使用 var 關鍵字宣告並初始化
    var arr1 [5]int = [5]int{1, 2, 3, 4, 5}
    fmt.Println(arr1)

    // 方式二:使用短變數宣告並初始化
    arr2 := [5]int{1, 2, 3, 4, 5}
    fmt.Println(arr2)

    // 方式三:宣告陣列但不初始化
    var arr3 [5]int
    fmt.Println(arr3)

    // 方式四:使用省略號自動推斷陣列長度
    arr4 := [...]int{1, 2, 3, 4, 5}
    fmt.Println(arr4)

    // 方式五:部分初始化陣列
    arr5 := [5]int{1, 2}
    fmt.Println(arr5)

    // 方式六:指定索引初始化陣列
    arr6 := [5]int{0: 1, 4: 5}
    fmt.Println(arr6)

    // 方式七:多維陣列的宣告和初始化
    var arr7 [2][3]int
    arr8 := [2][3]int{{1, 2, 3}, {4, 5, 6}}
    fmt.Println(arr7)
    fmt.Println(arr8)
}

陣列的記憶體分析:

在 Go 語言中,陣列的記憶體分配和佈局相對簡單且直觀。陣列是一個固定長度的、相同型別的元素序列,其記憶體佈局是連續的。

1. 記憶體分配

當宣告一個數組時,Go 語言會在記憶體中分配一塊連續的記憶體區域,用於儲存陣列的元素。陣列的長度在宣告時就已經確定,並且不能改變。

例如,宣告一個包含 5 個整數的陣列:

var arr [5]int

在這個例子中,Go 語言會在記憶體中分配一塊連續的記憶體區域,大小為 5 * sizeof(int) 位元組。假設 int 型別在當前平臺上佔用 4 個位元組,那麼這塊記憶體區域的大小就是 5 * 4 = 20 位元組。

2. 記憶體佈局

陣列的記憶體佈局是線性的,即陣列的每個元素在記憶體中是連續儲存的。陣列的第一個元素儲存在記憶體的起始位置,第二個元素緊隨其後,依此類推。

例如,對於陣列 arr := [5]int{1, 2, 3, 4, 5},其記憶體佈局如下:

記憶體地址:  |  arr[0]  |  arr[1]  |  arr[2]  |  arr[3]  |  arr[4]  |
值:       |    1     |    2     |    3     |    4     |    5     |

每個元素的記憶體地址可以透過陣列的基地址(即陣列的第一個元素的地址)加上元素的索引和元素型別的大小來計算。

3. 訪問陣列元素

由於陣列的記憶體佈局是連續的,訪問陣列元素非常高效。透過索引訪問陣列元素時,Go 語言會直接計算出該元素的記憶體地址,並從該地址讀取或寫入資料。

例如,訪問陣列 arr 的第三個元素:

value := arr[2]

Go 語言會計算出 arr[2] 的記憶體地址為 arr 的基地址加上 2 * sizeof(int) 位元組,然後從該地址讀取資料。

4. 陣列的傳遞

在 Go 語言中,陣列是值型別,這意味著當陣列作為引數傳遞給函式時,會進行一次完整的複製。如果陣列很大,這可能會導致效能問題。

例如:

func modifyArray(arr [5]int) {
    arr[0] = 100
}

func main() {
    arr := [5]int{1, 2, 3, 4, 5}
    modifyArray(arr)
    fmt.Println(arr)  // 輸出: [1 2 3 4 5]
}

在這個例子中,modifyArray 函式接收的是 arr 的一個副本,因此修改副本不會影響原始陣列。

陣列的遍歷:

在 Go 語言中,遍歷陣列有多種方式,常用的方法包括使用 for 迴圈和 range 關鍵字。以下是幾種常見的遍歷陣列的方法:

1. 使用 for 迴圈和索引遍歷陣列

這是最基本的遍歷方式,透過索引訪問陣列的每個元素。

package main

import "fmt"

func main() {
    arr := [5]int{1, 2, 3, 4, 5}

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

2. 使用 range 關鍵字遍歷陣列

range 關鍵字可以方便地遍歷陣列,它會返回索引和對應的元素值。

package main

import "fmt"

func main() {
    arr := [5]int{1, 2, 3, 4, 5}

    for index, value := range arr {
        fmt.Printf("Index: %d, Value: %d\n", index, value)
    }
}

3. 只使用 range 遍歷陣列的值

如果你只關心陣列的值而不關心索引,可以使用 _ 忽略索引。

package main

import "fmt"

func main() {
    arr := [5]int{1, 2, 3, 4, 5}

    for _, value := range arr {
        fmt.Println(value)
    }
}

4. 只使用 range 遍歷陣列的索引

如果你只關心陣列的索引而不關心值,可以只使用索引。

package main

import "fmt"

func main() {
    arr := [5]int{1, 2, 3, 4, 5}

    for index := range arr {
        fmt.Println(index)
    }
}

5. 使用 for 迴圈和 range 遍歷多維陣列

對於多維陣列,可以巢狀使用 for 迴圈和 range 關鍵字。

package main

import "fmt"

func main() {
    arr := [2][3]int{{1, 2, 3}, {4, 5, 6}}

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

    // 使用 range 遍歷多維陣列
    for i, row := range arr {
        for j, value := range row {
            fmt.Printf("arr[%d][%d] = %d\n", i, j, value)
        }
    }
}


0則評論

您的電子郵件等資訊不會被公開,以下所有項目均必填

OK! You can skip this field.