Go 語言數組

Go 語言提供了數組類型的數據結構。

數組是具有相同唯一類型的一組已編號且長度固定的數據項序列，這種類型可以是任意的原始類型例如整形、字符串或者自定義類型。

相對於去聲明number0, number1, ..., and number99的變量，使用數組形式numbers[0], numbers[1] ..., numbers[99]更加方便且易於擴展。

數組元素可以通過索引（位置）來讀取（或者修改），索引從0開始，第一個元素索引為 0，第二個索引為 1，以此類推。

聲明數組

Go 語言數組聲明需要指定元素類型及元素個數，語法格式如下

var array_name [SIZE] array_type

以上為一維數組的定義方式。數組長度必須是整數且大於 0。例如以下定義了數組 balance 長度為 10 類型為 float32：

var blance [5] float32

//如果不給初始化的值，默認就用根據數據類型填充數組的元素，float32的默認填充5個大鴨蛋([0 0 0 0 0])

初始化數組

以下演示了數組初始化：

var blance = [5] float32 {1000.0, 2.0, 3.4, 7.0, 50.0}

//給了初始化的值以後，數組中的元素為[1000 2 3.4 7 50]

註意:

1. 初始化數組中 {} 中的元素個數不能大於 [] 中的數字。
2. 如果忽略 [] 中的數字不設置數組大小，Go 語言會根據元素的個數來設置數組的大小：[...]

package main

import (
    "fmt"
)

func  main()  {
    //會自動計算初始化的值得個數
    var blance = [...] float32 {1000.0, 2.0, 3.4, 7.0, 50.0}
    //len函數是內部函數，會打印初始化數組中的元素個數
    fmt.Println(len(blance))
}

修改數組中第一個索引的值(數組的索引從0開始計算)

blance[1] = 101.21

//數組中的第二個元素就會被重新賦值為101.21，新數組的結果為[1000 101.21 3.4 7 50]

訪問數組中的值(不能超出數組的個數，不然會報錯)

func  main()  {
    //會自動計算初始化的值得個數
    var blance = [...] float32 {1000.0, 2.0, 3.4, 7.0, 50.0}
    blance[1] = 101.21
    //len函數是內部函數，會打印初始化數組中的元素個數
    fmt.Println(len(blance))
    fmt.Println(blance[4])
    /*超過索引的最大取值了，報錯了invalid array index 8 (out of bounds for 5-element array)
    fmt.Println(blance[8])
    */
}

以下演示了數組完整操作（聲明、賦值、訪問）的實例：

 1 package main
 2 
 3 import (
 4     "fmt"
 5 )
 6 
 7 func main(){
 8     //創建局部數組變量blance
 9     var blance = [...] string {"a", "b", "c", "d","e","f"}
10     //計算數組的個數
11     count := len(blance)
12     //初始化數組n
13     var n [6] int
14     for i := 0; i < count; i++{
15         //通過for循環，給n的索引賦值
16         n[i] = i + 10
17     }
18     
19     //訪問新創建的n數組裏面的值
20     for index,v := range n{
21         fmt.Printf("n數組中的第 %d 個索引為: %d \n",index,v)
22     }
23 }

以上代碼輸出的結果為：

n數組中的第 0 個索引為: 10
n數組中的第 1 個索引為: 11
n數組中的第 2 個索引為: 12
n數組中的第 3 個索引為: 13
n數組中的第 4 個索引為: 14
n數組中的第 5 個索引為: 15

Go 語言多維數組

Go 語言支持多維數組，以下為常用的多維數組聲明方式：

var array_name [SIZE1][SIZE2]...[SIZEN] array_type

二維數組

二維數組是最簡單的多維數組，二維數組本質上是由一維數組組成的。二維數組定義方式如下：

var arrayName [ x ][ y ] array_type

array_type 為 Go 語言的數據類型，arrayName 為數組名，二維數組可認為是一個表格，x 為行，y 為列，下圖演示了一個二維數組 a 為三行四列：

二維數組中的元素可通過 a[ i ][ j ] 來訪問。

初始化二位數組：

 func main(){
    //初始化二維數組
    var threedim = [2][5] int {
        {1,2,3,4,5},
        {6,7,8,9,10},
    }
    fmt.Println(threedim)
}

獲取第二維數組中第一個元素中的第四個值

func main(){
    //初始化二維數組,索引從0開始，第一個元素索引為0，第一個元素中第三個索引上的值
    var threedim = [2][5] int {
        {1,2,3,4,5},
        {6,7,8,9,10},
    }
    fmt.Println(threedim[0][3])
}

利用循環輸出二維數組的對應索引上的值

 1 package main
 2 
 3 import (
 4     "fmt"
 5 )
 6 
 7 func main(){
 8     //初始化二維數組
 9     var threedim = [3][5] int {
10         {1,2,3,4,5},
11         {6,7,8,9,10},
12         {11,12,13,14,15},
13     }
14     count := len(threedim)
15     for i := 0; i< count ; i++{
16         inner_count := len(threedim[i])
17         for j := 0; j < inner_count; j++{
18             fmt.Printf("threedim [%d][%d] = %d\n", i,j,threedim[i][j])
19         }
20 
21     }
22 }

以上代碼返回的結果為:

threedim [0][0] = 1
threedim [0][1] = 2
threedim [0][2] = 3
threedim [0][3] = 4
threedim [0][4] = 5
threedim [1][0] = 6
threedim [1][1] = 7
threedim [1][2] = 8
threedim [1][3] = 9
threedim [1][4] = 10
threedim [2][0] = 11
threedim [2][1] = 12
threedim [2][2] = 13
threedim [2][3] = 14
threedim [2][4] = 15

Go語言數組的使用