Go裡的map用於存放key/value對，在其它地方常稱為hash、dictionary、關聯陣列，這幾種稱呼都是對同一種資料結構的不同稱呼，它們都用於將key經過hash函式處理，然後對映到value，實現一一對應的關係。

map的內部結構

一個簡單的map結構示意圖：

在向map中儲存元素的時候，會將每個key經過hash運算，根據運算得到的hash值選擇合適的hash bucket(hash桶)，讓後將各個key/value存放到選定的hash bucket中。如果一來，整個map將根據bucket被細分成很多類別，每個key可能會交叉地存放到不同的bucket中。

所以，map中的元素是無序的，遍歷時的順序是隨機的，即使兩次以完全相同的順序存放完全相同的元素，也無法保證遍歷時的順序。

由於要對key進行hash計算選擇hash bucket，所以map的key必須具有唯一性，否則計算出的hash值相同，將人為出現hash衝撞。

在訪問、刪除元素時，也類似，都要計算key的hash值，然後找到對應的hash bucket，進而找到hash bucket中的key和value。

Go中的map是一個指標，它的底層是陣列，而且用到了兩個陣列，其中一個更底層的陣列用於打包儲存key和value。

建立、訪問map

可以通過make()建立map，它會先建立好底層資料結構，然後再建立map，並讓map指向底層資料結構。

my_map := make(map[string]int)

其中[string]表示map的key的資料型別，int表示key對應的值。

也可以直接通過大括號建立並初始化賦值：

// 空map
my_map := map[string]string{}

// 初始化賦值
my_map := map[string]string{"Red": "#da1337","Orange": '#e95a22"}

// 格式化賦值
my_map := map[string]int{
				"Java":11,
				"Perl":8,
				"Python":13,      // 注意結尾的逗號不能少
			}

其中map的key可以是任意內建的資料型別(如int)，或者其它可以通過"=="進行等值比較的資料型別，如interface和指標可以。slice、陣列、map、struct型別都不能作為key。

但value基本可以是任意型別，例如巢狀一個slice到map中：

my_map := map[string][]int{}

訪問map中的元素時，指定它的key即可，注意string型別的key必須加上引號：

my_map := map[string]int{
				"Java":11,
				"Perl":8,
				"Python":13,
			}

// 訪問
println(my_map["Perl"])

// 賦值已有的key & value
my_map["Perl"] = 12
println(my_map["Perl"])

// 賦值新的key & value
my_map["Shell"] = 14
println(my_map["Shell"])

nil map和空map

空map是不做任何賦值的map：

// 空map
my_map := map[string]string{}　

nil map，它將不會做任何初始化，不會指向任何資料結構：

// nil map
var my_map map[string]string

nil map和empty map的關係，就像nil slice和empty slice一樣，兩者都是空物件，未儲存任何資料，但前者不指向底層資料結構，後者指向底層資料結構，只不過指向的底層物件是空物件。使用println輸出看下即可知道：

package main

func main() {
	var nil_map map[string]string
	println(nil_map)

	emp_map := map[string]string{}
	println(emp_map)
}

輸出結果：

0x0
0xc04204de38

所以，map型別實際上就是一個指標。

map中元素的返回值

當訪問map中某個元素的時候，有兩種返回值的格式：

value := my_map["key"]
value,exists := my_map["key"]

第一種很好理解，就是檢索map中key對應的value值。如果key不存在，則value返回值對應資料型別的0。例如int為數值0，布林為false，字串為空""。

第二種不僅返回key對應的值，還根據key是否存在返回一個布林值賦值給exists變數。所以，當key存在時，value為對應的值，exists為true；當key不存在，value為0(同樣是各資料型別所代表的0)，exists為false。

看下例子：

package main

//	"fmt"

func main() {
	my_map := map[string]int{
		"Java":   11,
		"Perl":   8,
		"Python": 13,
	}

	value1 := my_map["Python"]
	value2, exists2 := my_map["Perl"]
	value3, exists3 := my_map["Shell"]

	println(value1)
	println(value2, exists2)
	println(value3, exists3)
}

上面將輸出如下結果：

13
8 true
0 false

在Go中設定類似於這種多個返回值的情況很多，即便是自己編寫函式也會經常設定它的exists屬性。

len()和delete()

len()函式用於獲取map中元素的個數，即有多個少key。delete()用於刪除map中的某個key。

package main

//	"fmt"

func main() {
	my_map := map[string]int{
		"Java":   11,
		"Perl":   8,
		"Python": 13,
		"Shell":  23,
	}

	println(len(my_map)) // 4

	delete(my_map, "Perl")

	println(len(my_map)) // 3
}

測試map中元素是否存在

兩種方式可以測試map中是否存在某個key：

1. 根據map元素的第二個返回值來判斷
2. 根據返回的value是否為0(不同資料型別的0不同)來判斷

方式一：直接訪問map中的該元素，將其賦值給兩個變數，第二個變數就是元素是否存在的修飾變數。

package main

//	"fmt"

func main() {
	my_map := map[string]int{
		"Java":   11,
		"Perl":   8,
		"Python": 13,
	}

	value, exists := my_map["Perl"]

	if exists {
		println("The key exists in map")
		println(value)
	}

}

可以將上面兩個步驟合併起來，看著更高大上一些：

if value,exists := my_map["Perl"];exists {
    println("key exists in map")
}

package main

import (
	"fmt"
)

func main() {
	my_map := map[string]int{
		"Java":   11,
		"Perl":   0,
		"Python": 13,
	}

	_, exist := my_map["Perl"]
	if exist {
		fmt.Println("exists in map")
	}

}

方式二：根據map元素返回的value判斷。因為該map中的value部分是int型別，所以它的0是數值的0。

my_map := map[string]int{
				"Java":11,
				"Perl":8,
				"Python":13,
			}

value := my_map["Shell"]
if value == 0 {
    println{"not exists in map"}
}

如果map的value資料型別是string，則判斷是否為空：

if value == "" {
    println("not exists in map")
}

由於map中的value有可能本身是存在的，但它的值為0，這時就會出現誤判斷。例如下面的"Shell"，它已經存在，但它對應的值為0。

my_map := map[string]int{
				"Java":11,
				"Perl":8,
				"Python":13,
				"Shell":0,
			}

所以，應當使用第一種方式進行判斷元素是否存在。

迭代遍歷map

因為map是key/value型別的資料結構，key就是map的index，所以range關鍵字對map操作時，將返回key和value。

package main

//"fmt"

func main() {
	my_map := map[string]int{
		"Java":   11,
		"Perl":   8,
		"Python": 13,
		"Shell":  23,
	}

	for key, value := range my_map {
		println("key:", key, " value:", value)
	}

}

如果range迭代map時，只給一個返回值，則表示迭代map的key：

package main

//"fmt"

func main() {
	my_map := map[string]int{
		"Java":   11,
		"Perl":   8,
		"Python": 13,
		"Shell":  23,
	}

	for key := range my_map {
		println("key:", key)
	}

	for _, value := range my_map {
		println("value:", value)
	}

}

獲取map中所有的key

Go中沒有提供直接獲取map所有key的函式。所以，只能自己寫，方式很簡單，range遍歷map，將遍歷到的key放進一個slice中儲存起來。

package main

import "fmt"

func main() {
	my_map := map[string]int{
		"Java":   11,
		"Perl":   8,
		"Python": 13,
		"Shell":  23,
	}

	// 儲存map中key的slice
	// slice型別要和map的key型別一致
	keys := make([]string, 0, len(my_map))

	// 將map中的key遍歷到keys中
	for map_key, _ := range my_map {
		keys = append(keys, map_key)
	}

	fmt.Println(keys)
}

注意上面宣告的slice中要限制長度為0，否則宣告為長度4、容量4的slice，而這4個元素都是空值，而且後面append()會直接對slice進行一次擴容，導致append()後的slice長度為map長度的2倍，前一半為空，後一般才是map中的key。

傳遞map給函式

map是一種指標，所以將map傳遞給函式，僅僅只是複製這個指標，所以函式內部對map的操作會直接修改外部的map。

例如，addone()用於給map的key對應的值加1。

package main

func main() {
	my_map := map[string]int{
		"Java":   11,
		"Perl":   8,
		"Python": 13,
		"Shell":  23,
	}

	println(my_map["Perl"])   // 8
	addone(my_map,"Perl") 
	println(my_map["Perl"])   // 9
}

func addone(m map[string]int,key string) {
	m[key] += 1
}

使用函式作為map的值

map的值可以是任意物件，包括函式、指標、stuct等等。如果將函式作為key對映的值，則可以用於實現一種分支結構。

map_func := map[KEY_TYPE]func() RETURN_TYPE {......}
map_func := make(map[KEY_TYPE]func() RETURN_TYPE)

例如：

package main

import "fmt"

func main() {
	mf := map[int]func() int{
		1: func() int { return 10 },
		2: func() int { return 20 },
		5: func() int { return 50 },
	}
	fmt.Println(mf) // 輸出函式的指標
	a := mf[1]()    // 呼叫某個分支的函式
	println(a)
}

package main

import "fmt"

func main() {
	mf := make(map[int]func() string)
	mf[1] = func() string { return "10" }
	mf[2] = func() string { return "20" }
	mf[3] = func() string { return "30" }
	mf[4] = func() string { return "40" }

	fmt.Println(mf[2]())
}