map 的基本介紹
map 是 key-value 資料結構，又稱為欄位或者關聯陣列。 

基本語法
var map 變數名  map[keytype]valuetype


key 可以是什麼型別
golang 中的 map，的 key 可以是很多種型別，比如 bool, 數字，string, 指標, channel , 還可以是隻包含前面幾個型別的 介面, 結構體, 陣列
通常 key 為 int 、string
注意:
slice， map 還有 function 不可以，因為這幾個沒法用 == 來判斷


valuetype 可以是什麼型別
valuetype 的型別和 key 基本一樣
通常為: 數字(整數,浮點數)，string，map，struct


map 宣告的舉例：
var a map[string]string
var a map[string]int
var a map[int]string
var a map[string]map[string]string

注意：宣告是不會分配記憶體的，初始化需要 make ，分配記憶體後才能賦值和使用。


案例演示：
func main() {
    
 
//map的宣告和注意事項 
    var a map[string]string
    //在使用map前，需要先make , make的作用就是給map分配資料空間
    a = make(map[string]string, 10)
    a["no1"] = "宋江"  
    a["no2"] = "吳用"  
    a["no1"] = "武松"  
    a["no3"] = "吳用"  
    fmt.Println(a)   // map[no1:武松 no2:吳用 no3:吳用]
}    

對上面程式碼的說明
map 在使用前一定要 make
map 的 key 是不能重複，如果重複了，則以最後這個 key
 
-value 為準
map 的 value 是可以相同的. 
map 的 key-value 是無序
make 內建函式數目



map的三種使用方法
方式 1
func main() {
    var a map[string]string
    //在使用map前，需要先make , make的作用就是給map分配資料空間
    a = make(map[string]string, 10)
    a["no1"] = "宋江"  
    a["no2"] = "吳用"  
    a["no3"] = "盧俊義"  
    fmt.Println(a)   // map[no1:宋江 no2:吳用 no3:盧俊義]
}   


方式 
 
2
func main() {
    cities := make(map[string]string)
    cities["no1"] = "北京"
    cities["no2"] = "天津"
    cities["no3"] = "上海"
    fmt.Println(cities)
}  


方式 3
func main() {
    heroes := map[string]string{
        "hero1" : "小滷蛋",
        "hero2" : "瑤瑤公主",
        "hero3" : "吉吉國王",
    }
    heroes["hero4"] = "高地虎"
    fmt.Println("heroes=", heroes)
}  



map 增加和更新
map["key"] = value 
如果 key 還沒有，就是增加，如果 key 存在就是修改
cities := make(map[string]string)
cities["no1"] = "北京"
cities["no2"] = "天津"
cities["no3"] = "上海"
fmt.Println(cities)
 
因為 no3這個key已經存在，因此下面的這句話就是修改
cities["no3"] = "杭州" 
fmt.Println(cities)


map 刪除：
說明：
delete(map，"key") ，delete 是一個內建函式，如果 key 存在，就刪除該 key-value
如果 key 不存在，不操作，但是也不會報錯


演示刪除
delete(cities, "no1")
fmt.Println(cities)
//當delete指定的key不存在時，刪除不會操作，也不會報錯
delete(cities, "no4")
fmt.Println(cities)



如果我們要刪除 map 的所有 key ,沒有一個專門的方法一次刪除，可以遍歷一下 key, 逐個刪除。或者 map = make(...)，make 一個新的，讓原來的成為垃圾，被 gc 回收



map 查詢：
//演示map的查詢
val, ok := cities["no1"]
if ok {
    fmt.Printf("有no1 key 值為%v\n", val)
} else {
    fmt.Printf("沒有no1 key\n")
}

如果 cities這個 map 中存在 "no2" ， 那麼 ok就會返回 true，否則返回 false




map的遍歷​​​​​​​
說明：map 的遍歷使用 for-range 的結構遍歷
案例演示1
//使用for-range遍歷map
cities := make(map[string]string)
cities["no1"] = "北京"
cities["no2"] = "天津"
cities["no3"] = "上海"
 
for k, v := range cities {
    fmt.Printf("k=%v v=%v\n", k, v)
}



map 的長度
cities := make(map[string]string)
cities["no1"] = "北京"
cities["no2"] = "天津"
cities["no3"] = "上海"
 
fmt.Println("cities 有", len(cities), " 對 key-value")




map切片
基本介紹
切片的資料型別如果是 map，則我們稱為 slice of map，map 切片，這樣使用則 map 個數就可以動態變化了。
案例演示
要求：使用一個 map 來記錄 monster 的資訊 name 和 age, 也就是說一個 monster 對應一個 map,並且妖怪的個數可以動態的增加=>map 切片
//1. 宣告一個map切片
var monsters []map[string]string
monsters = make([]map[string]string, 2) //準備放入兩個妖怪
//2. 增加第一個妖怪的資訊
if monsters[0] == nil {
    monsters[0] = make(map[string]string, 2)
    monsters[0]["name"] = "牛魔王"
    monsters[0]["age"] = "500"
}
 
if monsters[1] == nil {
    monsters[1] = make(map[string]string, 2)
    monsters[1]["name"] = "玉兔精"
    monsters[1]["age"] = "400"
}
 
// 下面這個寫法越界。
// if monsters[2] == nil {
//     monsters[2] = make(map[string]string, 2)
//     monsters[2]["name"] = "狐狸精"
//     monsters[2]["age"] = "300"
// }
 
//這裡我們需要使用到切片的append函式，可以動態的增加monster
//1. 先定義個monster資訊
newMonster := map[string]string{
    "name" : "黃鼠狼",
    "age" : "200",
}
monsters = append(monsters, newMonster)
 
fmt.Println(monsters)




map排序
golang 中沒有一個專門的方法針對 map 的 key 進行排序
golang 中的 map 預設是無序的，注意也不是按照新增的順序存放的，你每次遍歷，得到的輸出可能不一樣. 
golang 中 map 的排序，是先將 key 進行排序，然後根據 key 值遍歷輸出即可
案例演示
map1 := make(map[int]int, 10)
map1[10] = 100
map1[1] = 13
map1[4] = 56
map1[8] = 90
 
fmt.Println(map1)


如果按照map的key的順序進行排序輸出
先將map的key 放入到 切片中
 對切片排序 
遍歷切片，然後按照key來輸出map的值
var keys []int
for k, _ := range map1 {
    keys = append(keys, k)
}
//排序
sort.Ints(keys)
fmt.Println(keys)
 
for _, k := range keys{
    fmt.Printf("map1[%v]=%v \n", k, map1[k])
}



map使用細節
map 是引用型別，遵守引用型別傳遞的機制，在一個函式接收 map，修改後，會直接修改原來的 map
func modify(map1 map[int]int) {
    map1[10] = 900
}
func main() {
    //map是引用型別，遵守引用型別傳遞的機制，在一個函式接收map，
    //修改後，會直接修改原來的map
    map1 := make(map[int]int)
    map1[1] = 90
    map1[2] = 88
    map1[10] = 1
    map1[20] = 2
    modify(map1)
    fmt.Println(map1) 
}

結果 map1[10] = 900 ,說明map是引用型別



map 的容量達到後，再想 map 增加元素，會自動擴容，並不會發生 panic，也就是說 map 能動態的增長 鍵值對(key-value)
map1 := make(map[int]int, 2)
map1[1] = 90
map1[2] = 88
map1[10] = 1
map1[20] = 2