什麼是 map ？

map 是在 Go 中將值（value）與鍵（key）關聯的內建型別。通過相應的鍵可以獲取到值。

如何建立 map ？

通過向 make 函式傳入鍵和值的型別，可以建立 map。make(map[type of key]type of value) 是建立 map 的語法。

personSalary := make(map[string]int)

上面的程式碼建立了一個名為 personSalary 的 map，其中鍵是 string 型別，而值是 int 型別。

map 的零值是 nil。如果你想新增元素到 nil map 中，會觸發執行時 panic。因此 map 必須使用 make

package main

import (
    "fmt"
)

func main() {  
    var personSalary map[string]int
    if personSalary == nil {
        fmt.Println("map is nil. Going to make one.")
        personSalary = make(map[string]int)
    }
}

上面的程式中，personSalary 是 nil，因此需要使用 make 方法初始化，程式將輸出 map is nil. Going to make one.

給 map 新增元素

給 map 新增新元素的語法和陣列相同。下面的程式給 personSalary map 添加了幾個新元素。

package main

import (
    "fmt"
)

func main() {
    personSalary := make(map[string]int)
    personSalary["steve"] = 12000
    personSalary["jamie"] = 15000
    personSalary["mike"] = 9000
    fmt.Println("personSalary map contents:", personSalary)
}
 

上面的程式輸出：personSalary map contents: map[steve:12000 jamie:15000 mike:9000]

你也可以在宣告的時候初始化 map。

package main

import (  
    "fmt"
)

func main() {  
    personSalary := map[string]int {
        "steve": 12000,
        "jamie": 15000,
    }
    personSalary["mike"] = 9000
    fmt.Println("personSalary map contents:", personSalary)
}

上面的程式聲明瞭 personSalary，並在宣告的同時新增兩個元素。之後又添加了鍵 mike。程式輸出：

personSalary map contents: map[steve:12000 jamie:15000 mike:9000]

鍵不一定只能是 string 型別。所有可比較的型別，如 boolean，interger，float，complex，string 等，都可以作為鍵。關於可比較的型別，如果你想了解更多，請訪問 http://golang.org/ref/spec#Comparison_operators。

獲取 map 中的元素

目前我們已經給 map 添加了幾個元素，現在學習下如何獲取它們。獲取 map 元素的語法是 map[key] 。

package main

import (
    "fmt"
)

func main() {
    personSalary := map[string]int{
        "steve": 12000,
        "jamie": 15000,
    }
    personSalary["mike"] = 9000
    employee := "jamie"
    fmt.Println("Salary of", employee, "is", personSalary[employee])
}

上面的程式很簡單。獲取並列印員工 jamie 的薪資。程式輸出 Salary of jamie is 15000。

如果獲取一個不存在的元素，會發生什麼呢？map 會返回該元素型別的零值。在 personSalary 這個 map 裡，如果我們獲取一個不存在的元素，會返回 int 型別的零值 0。

package main

import (  
    "fmt"
)

func main() {
    personSalary := map[string]int{
        "steve": 12000,
        "jamie": 15000,
    }
    personSalary["mike"] = 9000
    employee := "jamie"
    fmt.Println("Salary of", employee, "is", personSalary[employee])
    fmt.Println("Salary of joe is", personSalary["joe"])
}

上面程式輸出：

Salary of jamie is 15000
Salary of joe is 0

上面程式返回 joe 的薪資是 0。personSalary 中不包含 joe 的情況下我們不會獲取到任何執行時錯誤。

如果我們想知道 map 中到底是不是存在這個 key，該怎麼做：

value, ok := map[key]

上面就是獲取 map 中某個 key 是否存在的語法。如果 ok 是 true，表示 key 存在，key 對應的值就是 value ，反之表示 key 不存在。

package main

import (
    "fmt"
)

func main() {
    personSalary := map[string]int{
        "steve": 12000,
        "jamie": 15000,
    }
    personSalary["mike"] = 9000
    newEmp := "joe"
    value, ok := personSalary[newEmp]
    if ok == true {
        fmt.Println("Salary of", newEmp, "is", value)
    } else {
        fmt.Println(newEmp,"not found")
    }
}

上面的程式中，第 15 行，joe 不存在，所以 ok 是 false。程式將輸出：

joe not found

遍歷 map 中所有的元素需要用 for range 迴圈。

package main

import (
    "fmt"
)

func main() {
    personSalary := map[string]int{
        "steve": 12000,
        "jamie": 15000,
    }
    personSalary["mike"] = 9000
    fmt.Println("All items of a map")
    for key, value := range personSalary {
        fmt.Printf("personSalary[%s] = %d\n", key, value)
    }

}

上面程式輸出：

All items of a map
personSalary[mike] = 9000
personSalary[steve] = 12000
personSalary[jamie] = 15000

有一點很重要，當使用 for range 遍歷 map 時，不保證每次執行程式獲取的元素順序相同。

刪除 map 中的元素

刪除 map 中 key 的語法是 delete(map, key)。這個函式沒有返回值。

package main

import (  
    "fmt"
)

func main() {  
    personSalary := map[string]int{
        "steve": 12000,
        "jamie": 15000,
    }
    personSalary["mike"] = 9000
    fmt.Println("map before deletion", personSalary)
    delete(personSalary, "steve")
    fmt.Println("map after deletion", personSalary)

}

上述程式刪除了鍵 "steve"，輸出：

map before deletion map[steve:12000 jamie:15000 mike:9000]
map after deletion map[mike:9000 jamie:15000]

獲取 map 的長度

獲取 map 的長度使用len函式。

package main

import (
    "fmt"
)

func main() {
    personSalary := map[string]int{
        "steve": 12000,
        "jamie": 15000,
    }
    personSalary["mike"] = 9000
    fmt.Println("length is", len(personSalary))

}

上述程式中的 len(personSalary) 函式獲取了 map 的長度。程式輸出 length is 3。

Map 是引用型別

和 slices 類似，map 也是引用型別。當 map 被賦值為一個新變數的時候，它們指向同一個內部資料結構。因此，改變其中一個變數，就會影響到另一變數。

package main

import (
    "fmt"
)

func main() {
    personSalary := map[string]int{
        "steve": 12000,
        "jamie": 15000,
    }
    personSalary["mike"] = 9000
    fmt.Println("Original person salary", personSalary)
    newPersonSalary := personSalary
    newPersonSalary["mike"] = 18000
    fmt.Println("Person salary changed", personSalary)

}

上面程式中的第 14 行，personSalary 被賦值給 newPersonSalary。下一行 ，newPersonSalary 中 mike 的薪資變成了 18000 。personSalary 中 Mike 的薪資也會變成 18000。程式輸出：

Original person salary map[steve:12000 jamie:15000 mike:9000]
Person salary changed map[steve:12000 jamie:15000 mike:18000]

當 map 作為函式引數傳遞時也會發生同樣的情況。函式中對 map 的任何修改，對於外部的呼叫都是可見的。

Map 的相等性

map 之間不能使用 == 操作符判斷，== 只能用來檢查 map 是否為 nil。

package main

func main() {
    map1 := map[string]int{
        "one": 1,
        "two": 2,
    }

    map2 := map1

    if map1 == map2 {
    }
}

上面程式丟擲編譯錯誤 invalid operation: map1 == map2 (map can only be compared to nil)。判斷兩個 map 是否相等的方法是遍歷比較兩個 map 中的每個元素。我建議你寫一段這樣的程式實現這個功能 。

我在一個程式裡實現了我們討論過的所有概念。你可以從 github 下載程式碼。

這就是 map 。謝謝你的閱讀。祝您愉快。