Array Type

  • 在Go裡，陣列為固定長度，元素型態和長度都是陣列型態的一部份

宣告

  • 使用 [n]type來宣告一個陣列，其中 n是數字，type 為型態
1
2
3
4
5
6
7
8
9
10
11
package main

import "fmt"

func main() {
	var arr [5]int
	arr[0] = 5
	arr[1] = 4
	
	fmt.Println(arr)  // [5 4 0 0 0]
}

  • 這裡宣告 arr 的型態是 [5]int ，因「元素型態與長度都是陣列型態的一部分」，所以 [10]int 與 [5]int 會是不同的型態。

  • 因為後面三個元素並沒有指定新值，但可以看到它的初值是 0 ，也就是 zero value 。

  • 宣告給值的話要使用 := 指定，也可以使用不固定長度 [...] 來宣告，它會依後面給值的數量來決定陣列長度：

1
2
3
4
5
6
7
8
9
10
11
12
13
package main

import "fmt"

func main() {
	arr1 := [3]int{1, 2, 3}
	arr2 := [5]int{1, 2, 3}
	arr3 := [...]int{1, 2, 3, 4, 5}
	
	fmt.Println(arr1)  // [1 2 3]
	fmt.Println(arr2)  // [1 2 3 0 0]
	fmt.Println(arr3)  // [1 2 3 4 5]
}
  • 如果存取陣列超過範圍時，會出現 out of bounds 的編譯錯誤
1
2
3
4
5
6
7
8
9
10
package main

import "fmt"

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

	fmt.Println(arr[9])  // invalid array index 9 (out of bounds for 5-element array)
}

複製

  • 陣列的內容是值，所以也可以複製給另一個變數
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package main

import "fmt"

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

 	fmt.Println(arr)         // [1 2 3 4 5]
	fmt.Println(arrCopy)     // [1 2 3 4 5]
	
	arr[0] = 10

	fmt.Println(arr)         // [10 2 3 4 5]
	fmt.Println(arrCopy)     // [1 2 3 4 5]
	
	var arrErr [10]int
	arrErr = arrCopy         // cannot use arrCopy (type [5]int) as type [10]int in assignment
}
  • 最後一行是型態不一致的錯，型態與長度相同，才有辦法複製值。

比較

  • 陣列可以用 == 與 != 來比較內容，一樣型態與長度相同才能比較。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package main

import "fmt"

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

 	fmt.Println(arr)             // [1 2 3 4 5]
	fmt.Println(arrCopy)         // [1 2 3 4 5]
	fmt.Println(arr == arrCopy)  // true
	
	arr[0] = 10

	fmt.Println(arr)             // [10 2 3 4 5]
	fmt.Println(arrCopy)         // [1 2 3 4 5]
	fmt.Println(arr == arrCopy)  // false
}

巢狀陣列

  • 當宣告陣列時， int 是一種型態，所以我們在前面加上 [n] 即成為 int 的陣列型態。
  • [n]int 也是一種型態，在前面加上 [m] 就會成為 [n]int 的陣列型態。
1
2
3
4
5
6
7
8
package main

import "fmt"

func main() {
	var arr [3][2]int
	fmt.Println(arr)    // [[0 0] [0 0] [0 0]]
}
  • 以上，這是一個有 3 個 [n]int 元素的陣列。
  • 巢狀陣列也可以宣告同時指定初值：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
package main

import "fmt"

func main() {
	arr1 := [3][2]int{{1, 2}, {3, 4}, {5, 6}}
	fmt.Println(arr1)    // [[1 2] [3 4] [5 6]]
	
	arr2 := [...][2]int{{1, 2}, {3, 4}, {5, 6}}
	fmt.Println(arr2)    // [[1 2] [3 4] [5 6]]

	arr3 := [...][...]int{{1, 2}, {3, 4}, {5, 6}}  // use of [...] array outside of array literal
	fmt.Println(arr3)
}
  • 其中 arr3 不能這樣宣告的原因是：因為長度也是型態的一部分，宣告陣列時元素的型態必須是確定的
  • 因此，[2]int 才能拿來做最外層陣列的元素型態， 而 [...]int 不行。

走訪 (我想翻譯成迭代？)

  • 陣列除了可以用 for + len() 來走訪外，也可以使用 for range ：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main

import "fmt"

func main() {
	arr := [3]int{1, 2, 3}
	for index, element := range arr {
		fmt.Printf("%d => %d\n", index, element)
	}
}


0 => 1
1 => 2
2 => 3