陣列

同一種類型的集合稱之為陣列，陣列是一組已編號且長度固定的資料項序列，陣列中可以是任意的相同型別，陣列的長度必須是一個常量或常量表達式，陣列的索引是從0開始，到len(Array) - 1 的長度，陣列的長度必須在宣告時就固定下來。在Go語言中，型別控制的是非常嚴格的，比如：[2]int 和 [3]int 就是兩種不同的型別。

使用

  func main() {
    // 先宣告，然後再賦值
    a := [2]int{}
    a[0] = 1
    a[1] = 2
    // 宣告的時候初始化
    b := [2]int{3, 4}
    // 以元素的個數初始化
    c := [...]int{5, 6, 7, 8}
    // 以下標初始化
    d := [4]int{1: 9, 3: 10}
    // 以 new 初始化, 返回陣列的指標
    e := new([5]int)

    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)
    fmt.Println(d)
    fmt.Println(e)
    // 輸出
    // [1 2]
    // [3 4]
    // [5 6 7 8]
    // [0 9 0 10]
    // &[0 0 0 0 0]
  }
 

二維陣列

  func main() {
     arr := [2][3]int{{12,13,14},{15,16,17}}

     fmt.Println(arr)
     // 輸出：
     // [[12 13 14] [15 16 17]]
  }

陣列在函式間的傳遞

能通過第一次的列印看出來，初始化出來的陣列都是值型別的，那麼陣列在函式間的傳遞也是值型別的嗎？

  func arrPrint(arr [4]int)  {
    arr[2] = 100
    fmt.Println("arrPrint:",arr)
  }

  func main() {
    arr := [4]int{1,2,3,4}
    arrPrint(arr)
    fmt.Println("main:",arr)
    // 輸出：
    // arrPrint: [1 2 100 4]
    // main: [1 2 3 4]
  }
 

能過上面的例子，可以發現，上現函式中修改了陣列中的值，但是 main 函式中的列印並沒有改變，所以可以確定，陣列在函式間傳遞的時候就是值傳遞。

這樣又會造成一個問題，因為值傳遞是陣列間的複製，如果一個數組小的時候，對效能影響不會很大，但是當一個數組非常大的時候，對程式的效能就會造成很大的影響了，所以為了解決這個問題，在使用陣列進行傳值的時候一般都會使用地址傳遞，在函式中使用指標型別的陣列進行接收。

在實際開發的時候，因為陣列的擴充套件性不好，所以一般不使用陣列，基本上使用的都是切片

陣列因為是值型別，所以，在型別完全相同的情況下支援使用 == !=比較