Go基礎系列：map類型

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。

看下例子：

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。

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中的該元素，將其賦值給兩個變量，第二個變量就是元素是否存在的修飾變量。

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

value,exists := my_map["Perl"]

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

能夠將上面兩個步驟合併起來，看着更高大上一些：

if value,exists := my_map["Perl"];exists {
    println("key 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。

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：

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

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

獲取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的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)

例如：

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)
}

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]())
}