Go字典使用詳解

更新時間：2022年11月18日 17:13:58 作者：Mingvvv

今天和大家一起學習Go語言的字典。Go語言的字典又稱為map，一種使用廣泛的數(shù)據(jù)結(jié)構(gòu)。它是擁有key/value對元素的「無序集合」，而且在集合中key必須是唯一的

存儲/查找原理

當我們要存儲或者查找某個鍵-元素對的時候，哈希表會先使用哈希函數(shù)將鍵值轉(zhuǎn)換為哈希值，哈希值一般是一個無符號的整數(shù)。

一個哈希表內(nèi)會存有一定數(shù)量的哈希桶，在字典的結(jié)構(gòu)里面，有一個屬性 B ，這個屬性代表當前字典里面桶的個數(shù) （2^B）。

	// A header for a Go map.
	type hmap struct {
	   // Note: the format of the hmap is also encoded in cmd/compile/internal/gc/reflect.go.
	   // Make sure this stays in sync with the compiler's definition.
	   count     int // # live cells == size of map.  Must be first (used by len() builtin)
	   flags     uint8
	   B         uint8  // log_2 of # of buckets (can hold up to loadFactor * 2^B items)
	   noverflow uint16 // approximate number of overflow buckets; see incrnoverflow for details
	   hash0     uint32 // hash seed
	   buckets    unsafe.Pointer // array of 2^B Buckets. may be nil if count==0.
	   oldbuckets unsafe.Pointer // previous bucket array of half the size, non-nil only when growing
	   nevacuate  uintptr        // progress counter for evacuation (buckets less than this have been evacuated)
	   extra *mapextra // optional fields
	}

比如當 B 為 5 的時候，通過獲取哈希值的低 5 位就能判斷出當前鍵-元素對應該存放在哪一個桶里面。例如我們通過哈希函數(shù)，獲取到了一個鍵-元素對中鍵值的哈希值為

1001011100001111011011001000111100101010001001011001010101011011

其中，低 5 位代表其所屬的桶的位置，11011 換算為十進制為 26 ，即該鍵-元素對存在第 26 個桶內(nèi)。哈希桶內(nèi)存儲的是“鍵的哈希值-內(nèi)部結(jié)構(gòu)”對的集合，即是按照鍵1 鍵2 … 鍵8 元素1 元素2 … 元素8 溢出指針的方式存儲，是一塊連續(xù)的內(nèi)存，且鍵和元素時捆綁存儲的。我們找到哈希桶之后，再對比鍵值，就可以定位我們所以需要的鍵的位置，又因為鍵 - 元素對是捆綁存儲的，所以找到了鍵就等于是找到對應的元素值。

存儲時也是同樣的道理，但是要注意的是，每一個存儲桶最多只能存儲 8 個鍵-元素對，當超出 8 個的時候，就會生成一個溢出桶，并且當前哈希桶的溢出指針（上述連續(xù)內(nèi)存的最后一塊）會指向新生成的溢出桶。

限制

其實從上面就可以看出，字典類型其實是一個哈希表的一個特定實現(xiàn)，其中鍵和元素的最大區(qū)別在于鍵必須是可以哈希的，而元素卻可以是任意類型的，因此字典中的鍵類型是受限的。

字典聲明

// 聲明字典 是個 nil 未初始化，直接存值會報錯
var s0 map[string] int
// 聲明字典并初始化
s1 := map[string]int{}    
// 使用 make 聲明
s2 := make(map[string] int)
fmt.Println(s0, s1, s2, s3)

-------結(jié)果-------------------------
map[] map[] map[]

要注意：聲明字典的時候 key 的類型不能是函數(shù)、字典、切片。因為根據(jù)上面查找字典鍵-元素對的過程可以知道，最后是要通過比較桶內(nèi)鍵和要查詢的鍵是不是一樣來確定鍵-元素對的位置的，但是這三種類型不支持判等操作，所以鍵的類型不支持這三種，編譯器會直接報錯。

但是有一個比較特殊的類型：接口 interface{}，interface{} 是支持判等操作的，所以編譯器不會報錯。但是又因為 interface{} 這個空接口相當于是個萬能類型，可以接受任何類型的值，所以會出現(xiàn)以下情況的代碼：

var s4 = map[interface{}]int{
	"1":      1,
	[]int{2}: 2,
	3:        3,
}
fmt.Println(s4)

------結(jié)果--------------
panic: runtime error: hash of unhashable type []int

當我們運行時，就會出現(xiàn) panic 恐慌。程序運行出現(xiàn)這樣的報錯我們還能及時調(diào)整，但在程序運行時，我們添加了這樣的鍵值對進去導致系統(tǒng)異常，再修改就為時已晚了，所以我們最好不要使用 interface{} 作為鍵的類型，而且我們要優(yōu)先考慮計算哈希值比較快的類型作為字典的鍵類型。

字典賦值

//初始化
s0 := map[string]int{}
fmt.Println(s0)
//添加key-value
s0["one"] = 1
s0["two"] = 2
fmt.Println(s0)
//修改指定key的值
s0["one"] = 11
s0["two"] = 22
fmt.Println(s0)
//刪除指定key的元素
delete(s0, "one")
fmt.Println(s0)
//獲取key-value對個數(shù)
fmt.Println(len(s0))

------結(jié)果-------------------
map[]
map[one:1 two:2]
map[one:11 two:22]
map[two:22]
1

特殊類型修改值

如果值的類型是數(shù)組或者結(jié)構(gòu)體，那么不能直接修改 value 成員

s0 := map[string]struct {
	x int
}{}
s0["one"] = struct{ x int }{1}
s0["two"] = struct{ x int }{2}
s0["one"].x = 1 //這里編譯器會直接報錯

方法一：先獲取全部value，修改之后重新賦值

s0 := map[string]struct {
	x int
}{}
s0["one"] = struct{ x int }{1}
s0["two"] = struct{ x int }{2}
s0["one"].x = 1 //這里編譯器會直接報錯
// 正確做法一
s1 := s0["one"]
s1.x = 111
s0["one"] = s1 
fmt.Println(s0)

-----結(jié)果------------------
map[one:{111} two:{2}]

方法二：使用指針類型

* 開頭表示是指針類型

& 是取址符號，即獲取對應程序?qū)嶓w對象的地址

// 正確做法二 
// value 的類型是指針類型，指針指向結(jié)構(gòu)體
s0 := map[string]*struct {
	x int
}{}
//創(chuàng)建一個結(jié)構(gòu)體并把指針添加到字典中
s0["one"] = &struct{ x int }{1}
fmt.Println(*s0["one"])
s0["one"].x = 111
fmt.Println(*s0["one"])

-----結(jié)果------------------
{1}
{111}

字典遍歷

s0 := map[string]int{}
s0["one"] = 1
s0["two"] = 2
//接收 key 和 value
for k, vla := range s0 {
	fmt.Printf("%s:%d\n", k, vla)
}
fmt.Println("-----分割線---------------")
//只接收key
for k := range s0 {
	fmt.Printf("%s:%d\n", k, s0[k])
}