到目前為止我們看過了一些簡單的型別和結構。現在該是時候來看看 array、slice 和 map 了。
如果你來自 Python、Ruby、Perl、JavaScript 或 PHP（或更多其他語言），你可能在寫程式時習慣使用動態陣列。這些陣列是在資料加入到陣列時自行調整大小的陣列。在 Go 中，像許多其他語言一樣，陣列是固定的。宣告陣列需要我們指定大小，一旦指定大小，它就不能增加：
var scores [10]int
scores[0] = 339上面這個陣列宣告可以透過 scores[0] 到 scores[9] 來存取 10 個分數值。如果嘗試存取超過這個範圍的陣列元素，編譯器會拋出執行時期錯誤。
我們也可以在初始化陣列的時候賦值：
scores := [4]int{9001, 9333, 212, 33}我們可以用 len 函式來取得陣列的長度。而 range 函式可以用來循序的存取每個元素值：
for index, value := range scores {
}使用陣列是有效率但不夠靈活，原因是因為通常我們不知道即將要處理元素的數量。讓我們來看看 slice。
在 Go 中，你很少會直接使用陣列，通常情況下你會使用 slice。slice 是一個輕量級的結構，這個結構被封裝後，代表了一個陣列的一部份。這裡我們列出一些建立 slice 的方法，並且指出我們會在後面什麼時候會用到他們。
第一種方式和我們建立陣列時有點相像：
scores := []int{1,4,293,4,9}不同於陣列的宣告，slice 在宣告時不需要宣告長度。為了理解兩者的差異，我們來看看另外一種使用 make 建立 slice 的方式：
scores := make([]int, 10)我們使用 make 而沒有使用 new 是因為建立一個 slice 不僅僅是分配一個記憶體區間而已（new 的作用就是分配一段記憶體區間）。明確的來說，我們幫底層的陣列建立了一段記憶體區間，同時也要初始化 slice。在上面的例子中，我們初始化一個 slice，長度和容量都是 10。長度代表 slice 的大小，而容量是底層陣列的大小。透過 make 函式，我們可以同時宣告長度和容量。
scores := make([]int, 0, 10)這會建立一個長度是 0 ，容量是 10 的 slice。（如果你有留意的話，會發現 make 和 len 同時實現了 重載 的功能。Go 語言的某些特性會讓你感到有點失望，因為某些部分他並沒有揭露給開發者使用。）
為了更好理解關於長度和容量之間的交互關係，讓我們來看一些例子：
func main() {
scores := make([]int, 0, 10)
scores[7] = 9033
fmt.Println(scores)
}上面的第一個例子是無法運作的，為什麼？因為我們的 slice 長度是 0。是的，底層的陣列有 10 個元素，
但如果想要存取元素時，我們必須明確的擴展 slice。其中一個擴展 slice 的方式是使用 append：
func main() {
scores := make([]int, 0, 10)
scores = append(scores, 5)
fmt.Println(scores) // 列印 [5]
}但這改變了我們原本程式碼的意圖，在長度為 0 的 slice 上增加一個元素會被放到 slice 的第一個元素。不管出自什麼原因，那段不能運作的程式碼會賦值給 slice 的第 8 個元素。為了達成這個目標，我們可以再切割 slice：
func main() {
scores := make([]int, 0, 10)
scores = scores[0:8]
scores[7] = 9033
fmt.Println(scores)
}可以調整 slice 長度的上限是多少？這個上限就是根據 slice 的容量來決定，在上面的例子中，就是 10。你可能會認為這沒有解決 固定長度陣列 的問題。其實 append 是比較特別的，如果底層的陣列已經滿了，append 會創造一個更大的陣列，並且複製所有的值到新的陣列（這也是動態陣列的工作原理，像是：PHP、Python、Ruby、Javascript等）。這就是為什麼我們在上面的例子中使用 append，我們必須要將 append 得回傳值重新指派給 scores 變數，如果原始的 slice 沒有更多容量時，append 會建立一個新的。
如果我告訴你 Go 在擴展陣列時使用的是 2x 演算法，你可以猜到以下的程式碼的輸出是什麼嗎？
func main() {
scores := make([]int, 0, 5)
c := cap(scores)
fmt.Println(c)
for i := 0; i < 25; i++ {
scores = append(scores, i)
// 如果容量改變了，
// Go 為了容納新的資料，會增加陣列的長度
if cap(scores) != c {
c = cap(scores)
fmt.Println(c)
}
}
}如果初始 scores 的容量是 5，為了要容納 20 個元素，slice 的容量必須要擴展 3 次，分別是10、20 和 40。
最後一個範例：
func main() {
scores := make([]int, 5)
scores = append(scores, 9332)
fmt.Println(scores)
}上面的程式碼輸出會是 [0, 0, 0, 0, 0, 9332]。從直觀來看，你可能會以為輸出是 [9332, 0, 0, 0, 0]？對編譯器而言，上面的程式碼代表的意思是，附加 9332 到已經有五個值的 slice 。
最後，這裡提供四種常見初始化 slice 的方式：
names := []string{"leto", "jessica", "paul"}
checks := make([]bool, 10)
var names []string
scores := make([]int, 0, 20)你該使用哪一種方式？
第一種方式相當直觀，不需要太多的說明，但缺點是你必須先知道要往 slice 裡面放的元素是什麼。第二種方式在你想要往 slice 的特定位置寫入一個值的時候很有用，比如說：
func extractPowers(saiyans []*Saiyans) []int {
powers := make([]int, len(saiyans))
for index, saiyan := range saiyans {
powers[index] = saiyan.Power
}
return powers
}第三個方式會回傳一個空的 slice，一般會和 append 一起使用。此時 slice 的數量是未知的。
最後一種方式讓我們指定 slice 的長度和容量。當我們大概知道需要多少元素時很有用。即使你知道元素的個數，append 也可以被使用。這取決於個人喜好：
func extractPowers(saiyans []*Saiyans) []int {
powers := make([]int, 0, len(saiyans))
for _, saiyan := range saiyans {
powers = append(powers, saiyan.Power)
}
return powers
}slice 作為一個陣列的封裝來說是很有用的。許多語言都有類似的概念。Javascript 和 Ruby 中都有一個 slice 方法。在 Ruby 中，你可以透過 [START..END] 來得到一個 slice，或是在 Python 中使用 [START:END] 來得到一個 slice。然而，在某些語言中，slice 的確是從原始陣列複製而來。如果我們使用 Ruby，下面的程式碼會輸出什麼？
scores = [1,2,3,4,5]
slice = scores[2..4]
slice[0] = 999
puts scores答案是 [1, 2, 3, 4, 5]。因為 slice 是把舊的值全部複製過來的一個新陣列。現在，同樣情況下來看看 Go 會怎麼做：
scores := []int{1,2,3,4,5}
slice := scores[2:4]
slice[0] = 999
fmt.Println(scores)輸出會是 [1, 2, 999, 4, 5]。
這種行為會如何改變你的程式碼？例如，很多函式會需要位置參數。在 JavaScript 中，如果我們想要在前五個字元後尋找一個空白（是的，slice 也可以在字串中使用），我們可以這樣寫：
haystack = "the spice must flow";
console.log(haystack.indexOf(" ", 5));在 Go 語言中，我們使用 slice 來做：
strings.Index(haystack[5:], " ")從上面的例子中，我們可以看到 [X:] 是代表 從 X 到結尾 的縮寫。而 [:X] 代表的是 從開始到 X 的縮寫。跟其他語言不同的是，Go 不支援負索引值，如果我們想要除了最後一個以外的所有值，可以這樣寫：
scores := []int{1, 2, 3, 4, 5}
scores = scores[:len(scores) - 1]下面的例子是從一個未排序 slice 中去除一個值的有效方法。
func main() {
scores := []int{1, 2, 3, 4, 5}
scores = removeAtIndex(scores, 2)
fmt.Println(scores)
}
func removeAtIndex(source []int, index int) []int {
lastIndex := len(source) - 1
// 交換最後的值並移除我們想要除的值
source[index], source[lastIndex] = source[lastIndex], source[index]
return source[:lastIndex]
}我們已經瞭解了 slice。最後，再來學習一下一個常見的內建函式 copy。copy 是許多的函式中顯著會改變我們如何撰寫程式碼的函式之一。一般來說，複製陣列的值到另外一個陣列會需要五個參數：source, sourceStart, count, destination 和 destinationStart。但使用 slice，我們只需要兩個參數：
import (
"fmt"
"math/rand"
"sort"
)
func main() {
scores := make([]int, 100)
for i := 0; i < 100; i++ {
scores[i] = int(rand.Int31n(1000))
}
sort.Ints(scores)
worst := make([]int, 5)
copy(worst, scores[:5])
fmt.Println(worst)
}花點時間研究上面的程式碼。試著改變一些部分。如果你使用 copy(worst[2:4], scores[:5]) 方式去複製，看看會產生什麼結果？或者試著複製多於或者少於 5 個值到 worst。
在 Go 語言中的 Map 就如同其他語言的 hashtable 或 dictionary。他們的功用正如同你想像的：定義鍵和值，你可以從 map 中取得、設定或刪除該值。
Map 和 slice 一樣，可以透過 make 函式來建立。讓我們來看個例子：
func main() {
lookup := make(map[string]int)
lookup["goku"] = 9001
power, exists := lookup["vegeta"]
// 列印 0，false
// Integer 的預設值為 0
fmt.Println(power, exists)
}使用 len 可以取得鍵值的數量。可以透過 delete 函式來刪除特定鍵的值。
// 回傳 1
total := len(lookup)
// 沒有任何的回傳，可以呼叫一個不存在的 key
delete(lookup, "goku")Map 是動態增長的。然而，我們可以在 make 函式中透過設定第二個參數來給訂初始大小：
lookup := make(map[string]int, 100)如果你對於有多少鍵值有概念的話，預先定義初始化大小有助於提升效能。
當你需要把結構的欄位定義為一個 map 時，可以這樣做：
type Saiyan struct {
Name string
Friends map[string]*Saiyan
}初始化上面這個結構的一種方式：
goku := &Saiyan{
Name: "Goku",
Friends: make(map[string]*Saiyan),
}
goku.Friends["krillin"] = ... // 待完成的 krillin 或建立 Krillin這裡還有另外一種方式可以宣告和初始化一個 map。類似 make，這種方式可以用來初始化 map 和陣列。我們可以這樣宣告：
lookup := map[string]int{
"goku": 9001,
"gohan": 2044,
}我們可以使用 for 迴圈和 range 關鍵字來遍歷 map：
for key, value := range lookup {
...
}要特別注意的是，遍歷 map 是沒有順序性的。每一次的遍歷返回的鍵值對都是隨機的。
我們在第二章時已經討論過什麼時候要傳遞指針、什麼時候要傳遞值。現在我們學習到了陣列和 map，再來看看該使用以下哪一種方式？
a := make([]Saiyan, 10)
// 或
b := make([]*Saiyan, 10)很多開發者會認為傳遞 b 到一個函式，或是回傳一個 b 會比較有效率，但事實上，我們傳遞或返回的都是一個 slice 的拷貝，所以就傳遞或返回這個 slice 而言，是沒有什麼差別的。
你會看見不同的地方是在於如果你要修改 slice 或 map 的值。在這點上，同樣的邏輯我們已經在第二章看過。所以是定義一個陣列指針或陣列值，取決於你怎麼使用單個值，而不是怎麼使用陣列或 map 本身來決定。
陣列和 map 在 Go 中跟其他的語言很類似，如果你曾經使用過動態陣列，可能需要一點時間適應，但是 append 應該會解決掉大部分不適應的地方。如果我們拋開陣列表面的語法，你會發現 slice 是很強大的。使用 slice 對於維持程式碼的簡潔有很大幫助。
這邊有一些極端案例我們沒有提到，但你應該很少會遇到這些案例。如果你碰到了，希望我們為你打下的基礎可以讓你了解是怎麼回事。