make(map[KeyType]ValueType, [cap])

func main() {
    scoreMap := make(map[string]int, 8)
    scoreMap["張三"] = 90
    scoreMap["小明"] = 100
    fmt.Println(scoreMap)
    fmt.Println(scoreMap["小明"])
    fmt.Printf("type of a:%T\n", scoreMap)
}   

func main() {
    userInfo := map[string]string{
        "username": "pprof.cn",
        "password": "123456",
    }
    fmt.Println(userInfo) //
}

func main() {
    scoreMap := make(map[string]int)
    scoreMap["張三"] = 90
    scoreMap["小明"] = 100
    // 如果key存在ok為true,v為對應的值；不存在ok為false,v為值類型的零值
    v, ok := scoreMap["張三"]
    if ok {
        fmt.Println(v)
    } else {
        fmt.Println("查無此人")
    }
}  

func main() {
    scoreMap := make(map[string]int)
    scoreMap["張三"] = 90
    scoreMap["小明"] = 100
    scoreMap["王五"] = 60
    for k, v := range scoreMap {
        fmt.Println(k, v)
    }
}  

func main() {
    scoreMap := make(map[string]int)
    scoreMap["張三"] = 90
    scoreMap["小明"] = 100
    scoreMap["王五"] = 60
    for k := range scoreMap {
        fmt.Println(k)
    }
}  

func main(){
    scoreMap := make(map[string]int)
    scoreMap["張三"] = 90
    scoreMap["小明"] = 100
    scoreMap["王五"] = 60
    delete(scoreMap, "小明")//將小明:100從map中刪除
    for k,v := range scoreMap{
        fmt.Println(k, v)
    }
}  

 func main() {
    rand.Seed(time.Now().UnixNano()) //初始化隨機數(shù)種子
    var scoreMap = make(map[string]int, 200)
    for i := 0; i < 100; i++ {
        key := fmt.Sprintf("stu%02d", i) //生成stu開頭的字符串
        value := rand.Intn(100)          //生成0~99的隨機整數(shù)
        scoreMap[key] = value
    }
    //取出map中的所有key存入切片keys
    var keys = make([]string, 0, 200)
    for key := range scoreMap {
        keys = append(keys, key)
    }
    //對切片進行排序
    sort.Strings(keys)
    //按照排序后的key遍歷map
    for _, key := range keys {
        fmt.Println(key, scoreMap[key])
    }
}

func main() {
    var mapSlice = make([]map[string]string, 3)
    for index, value := range mapSlice {
        fmt.Printf("index:%d value:%v\n", index, value)
    }
    fmt.Println("after init")
    // 對切片中的map元素進行初始化
    mapSlice[0] = make(map[string]string, 10)
    mapSlice[0]["name"] = "王五"
    mapSlice[0]["password"] = "123456"
    mapSlice[0]["address"] = "紅旗大街"
    for index, value := range mapSlice {
        fmt.Printf("index:%d value:%v\n", index, value)
    }
} 

func main() {
    var sliceMap = make(map[string][]string, 3)
    fmt.Println(sliceMap)
    fmt.Println("after init")
    key := "中國"
    value, ok := sliceMap[key]
    if !ok {
        value = make([]string, 0, 2)
    }
    value = append(value, "北京", "上海")
    sliceMap[key] = value
    fmt.Println(sliceMap)
}

type f func(int) bool
type m map[int]byte
type s []int
type i int
var m1 map[i]f
fmt.Println(m1)
/** 函數(shù)、map、切片不能當key **/
// var m2 map[f]bool
// fmt.Println(m2)
// var m3 map[m]bool
// fmt.Println(m3)
// var m4 map[s]bool
// fmt.Println(m4)
type user struct {
	scores float32 //如果scores是slice，則user不能作為map的key
}
u := user{}
m5 := make(map[user]interface{})
m5[u] = 5
fmt.Println(m5)

    length = len(array) = 4
    hashkey1 = hash(xiaoming) = 4
    index1  = hashkey1% length= 0
    hashkey2 = hash(xiaoli) = 6
    index2  = hashkey2% length= 2

//直接創(chuàng)建初始化一個mao
var mapInit = map[string]string {"xiaoli":"湖南", "xiaoliu":"天津"}
//聲明一個map類型變量,
//map的key的類型是string，value的類型是string
var mapTemp map[string]string
//使用make函數(shù)初始化這個變量,并指定大小(也可以不指定)
mapTemp = make(map[string]string,10)
//存儲key ，value
mapTemp["xiaoming"] = "北京"
mapTemp["xiaowang"]= "河北"
//根據(jù)key獲取value,
//如果key存在，則ok是true，否則是flase
//v1用來接收key對應的value,當ok是false時，v1是nil
v1,ok := mapTemp["xiaoming"]
fmt.Println(ok,v1)
//當key=xiaowang存在時打印value
if v2,ok := mapTemp["xiaowang"]; ok{
    fmt.Println(v2)
}
//遍歷map,打印key和value
for k,v := range mapTemp{
    fmt.Println(k,v)
}
//刪除map中的key
delete(mapTemp,"xiaoming")
//獲取map的大小
l := len(mapTemp)
fmt.Println(l)

//bucket結構體定義 b就是bucket
type bmap{
    // tophash generally contains the top byte of the hash value
    // for each key  in this bucket. If tophash[0] < minTopHash,
    // tophash[0] is a bucket               evacuation state instead.
    //翻譯：top hash通常包含該bucket中每個鍵的hash值的高八位。
    如果tophash[0]小于mintophash，則tophash[0]為桶疏散狀態(tài)    //bucketCnt 的初始值是8
    tophash [bucketCnt]uint8
    // Followed by bucketCnt keys and then bucketCnt values.
    // NOTE: packing all the keys together and then all the values together makes the    // code a bit more complicated than alternating key/value/key/value/... but it allows    // us to eliminate padding which would be needed for, e.g., map[int64]int8.// Followed by an overflow pointer.    //翻譯：接下來是bucketcnt鍵，然后是bucketcnt值。
    注意：將所有鍵打包在一起，然后將所有值打包在一起，    使得代碼比交替鍵/值/鍵/值/更復雜。但它允許//我們消除可能需要的填充，    例如map[int64]int8./后面跟一個溢出指針}

func mapassign(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {
    //獲取hash算法
    alg := t.key.alg
    //計算hash值
    hash := alg.hash(key, uintptr(h.hash0))
    //如果bucket數(shù)組一開始為空，則初始化
    if h.buckets == nil {
        h.buckets = newobject(t.bucket) // newarray(t.bucket, 1)
    }
again:
    // 定位存儲在哪一個bucket中
    bucket := hash & bucketMask(h.B)
    //得到bucket的結構體
    b := (*bmap)(unsafe.Pointer(uintptr(h.buckets) +bucket*uintptr(t.bucketsize)))
    //獲取高八位hash值
    top := tophash(hash)
    var inserti *uint8
    var insertk unsafe.Pointer
    var val unsafe.Pointer
bucketloop:
    //死循環(huán)
    for {
        //循環(huán)bucket中的tophash數(shù)組
        for i := uintptr(0); i < bucketCnt; i++ {
            //如果hash不相等
            if b.tophash[i] != top {
             //判斷是否為空，為空則插入
                if isEmpty(b.tophash[i]) && inserti == nil {
                    inserti = &b.tophash[i]
                    insertk = add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
                    val = add( unsafe.Pointer(b), 
                    dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.valuesize) )
                }
              //插入成功，終止最外層循環(huán)
                if b.tophash[i] == emptyRest {
                    break bucketloop
                }
                continue
            }
            //到這里說明高八位hash一樣，獲取已存在的key
            k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
            if t.indirectkey() {
                k = *((*unsafe.Pointer)(k))
            }
            //判斷兩個key是否相等，不相等就循環(huán)下一個
            if !alg.equal(key, k) {
                continue
            }
            // 如果相等則更新
            if t.needkeyupdate() {
                typedmemmove(t.key, k, key)
            }
            //獲取已存在的value
            val = add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.valuesize))
            goto done
        }
        //如果上一個bucket沒能插入，則通過overflow獲取鏈表上的下一個bucket
        ovf := b.overflow(t)
        if ovf == nil {
            break
        }
        b = ovf
    }
    if inserti == nil {
        // all current buckets are full, allocate a new one.
        newb := h.newoverflow(t, b)
        inserti = &newb.tophash[0]
        insertk = add(unsafe.Pointer(newb), dataOffset)
        val = add(insertk, bucketCnt*uintptr(t.keysize))
    }
    // store new key/value at insert position
    if t.indirectkey() {
        kmem := newobject(t.key)
        *(*unsafe.Pointer)(insertk) = kmem
        insertk = kmem
    }
    if t.indirectvalue() {
        vmem := newobject(t.elem)
        *(*unsafe.Pointer)(val) = vmem
    }
    typedmemmove(t.key, insertk, key)
    //將高八位hash值存儲
    *inserti = top
    h.count++
    return val
}