mmap: =make([string]string)//make 初始化一个key是string，value是：stringmmap: =map[string]string{"key":"value"} // 普通初始化mmap:=new(map[string]string) // 这里初始化一个指针，但是需要赋值，不推荐var mmap map[string]string // 声明一个nil的map

//获取map存储的键值对的个数length:=len(mmap)// 获取map容量 capacity:=cap(mmap) 无法执行会报错mmap["1"]="1" // 添加元素mmap["1"]="12" // 修改元素delete(mmap,"1")//删除for k,v:=range mmap {	// 遍历}// 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}

func makemap(t *maptype, hint int, h *hmap) *hmap {	mem, overflow := math.MulUintptr(uintptr(hint), t.bucket.size)	if overflow || mem > maxAlloc {		hint = 0	}
	// initialize Hmap	if h == nil {		h = new(hmap)	}	h.hash0 = fastrand()
	// Find the size parameter B which will hold the requested # of elements.	// For hint < 0 overLoadFactor returns false since hint < bucketCnt.	B := uint8(0)	for overLoadFactor(hint, B) {		B++	}	h.B = B
	// allocate initial hash table	// if B == 0, the buckets field is allocated lazily later (in mapassign)	// If hint is large zeroing this memory could take a while.	if h.B != 0 {		var nextOverflow *bmap		h.buckets, nextOverflow = makeBucketArray(t, h.B, nil)		if nextOverflow != nil {			h.extra = new(mapextra)			h.extra.nextOverflow = nextOverflow		}	}
	return h}

// Like mapaccess, but allocates a slot for the key if it is not present in the map.func mapassign(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {	if h == nil {		panic(plainError("assignment to entry in nil map"))	}	if raceenabled {		callerpc := getcallerpc()		pc := funcPC(mapassign)		racewritepc(unsafe.Pointer(h), callerpc, pc)		raceReadObjectPC(t.key, key, callerpc, pc)	}	if msanenabled {		msanread(key, t.key.size)	}	if h.flags&hashWriting != 0 {		throw("concurrent map writes")	}	hash := t.hasher(key, uintptr(h.hash0))
	// Set hashWriting after calling t.hasher, since t.hasher may panic,	// in which case we have not actually done a write.	h.flags ^= hashWriting
	if h.buckets == nil {		h.buckets = newobject(t.bucket) // newarray(t.bucket, 1)	}
again:	bucket := hash & bucketMask(h.B)	if h.growing() {		growWork(t, h, bucket)	}	b := (*bmap)(unsafe.Pointer(uintptr(h.buckets) + bucket*uintptr(t.bucketsize)))	top := tophash(hash)
	var inserti *uint8	var insertk unsafe.Pointer	var elem unsafe.Pointerbucketloop:	for {		for i := uintptr(0); i < bucketCnt; i++ {			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))					elem = add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.elemsize))				}				if b.tophash[i] == emptyRest {					break bucketloop				}				continue			}			k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))			if t.indirectkey() {				k = *((*unsafe.Pointer)(k))			}			if !t.key.equal(key, k) {				continue			}			// already have a mapping for key. Update it.			if t.needkeyupdate() {				typedmemmove(t.key, k, key)			}			elem = add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.elemsize))			goto done		}		ovf := b.overflow(t)		if ovf == nil {			break		}		b = ovf	}
	// Did not find mapping for key. Allocate new cell & add entry.
	// If we hit the max load factor or we have too many overflow buckets,	// and we're not already in the middle of growing, start growing.	if !h.growing() && (overLoadFactor(h.count+1, h.B) || tooManyOverflowBuckets(h.noverflow, h.B)) {		hashGrow(t, h)		goto again // Growing the table invalidates everything, so try again	}
	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)		elem = add(insertk, bucketCnt*uintptr(t.keysize))	}
	// store new key/elem at insert position	if t.indirectkey() {		kmem := newobject(t.key)		*(*unsafe.Pointer)(insertk) = kmem		insertk = kmem	}	if t.indirectelem() {		vmem := newobject(t.elem)		*(*unsafe.Pointer)(elem) = vmem	}	typedmemmove(t.key, insertk, key)	*inserti = top	h.count++
done:	if h.flags&hashWriting == 0 {		throw("concurrent map writes")	}	h.flags &^= hashWriting	if t.indirectelem() {		elem = *((*unsafe.Pointer)(elem))	}	return elem}

// mapaccess1 returns a pointer to h[key].  Never returns nil, instead// it will return a reference to the zero object for the elem type if// the key is not in the map.// NOTE: The returned pointer may keep the whole map live, so don't// hold onto it for very long.func mapaccess1(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {	if raceenabled && h != nil {		callerpc := getcallerpc()		pc := funcPC(mapaccess1)		racereadpc(unsafe.Pointer(h), callerpc, pc)		raceReadObjectPC(t.key, key, callerpc, pc)	}	if msanenabled && h != nil {		msanread(key, t.key.size)	}	if h == nil || h.count == 0 {		if t.hashMightPanic() {			t.hasher(key, 0) // see issue 23734		}		return unsafe.Pointer(&zeroVal[0])	}	if h.flags&hashWriting != 0 {		throw("concurrent map read and map write")	}	hash := t.hasher(key, uintptr(h.hash0))	m := bucketMask(h.B)	b := (*bmap)(add(h.buckets, (hash&m)*uintptr(t.bucketsize)))	if c := h.oldbuckets; c != nil {		if !h.sameSizeGrow() {			// There used to be half as many buckets; mask down one more power of two.			m >>= 1		}		oldb := (*bmap)(add(c, (hash&m)*uintptr(t.bucketsize)))		if !evacuated(oldb) {			b = oldb		}	}	top := tophash(hash)bucketloop:	for ; b != nil; b = b.overflow(t) {		for i := uintptr(0); i < bucketCnt; i++ {			if b.tophash[i] != top {				if b.tophash[i] == emptyRest {					break bucketloop				}				continue			}			k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))			if t.indirectkey() {				k = *((*unsafe.Pointer)(k))			}			if t.key.equal(key, k) {				e := add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.elemsize))				if t.indirectelem() {					e = *((*unsafe.Pointer)(e))				}				return e			}		}	}	return unsafe.Pointer(&zeroVal[0])}

type mapextra struct {	// If both key and elem do not contain pointers and are inline, then we mark bucket	// type as containing no pointers. This avoids scanning such maps.	// However, bmap.overflow is a pointer. In order to keep overflow buckets	// alive, we store pointers to all overflow buckets in hmap.extra.overflow and hmap.extra.oldoverflow.	// overflow and oldoverflow are only used if key and elem do not contain pointers.	// overflow contains overflow buckets for hmap.buckets.	// oldoverflow contains overflow buckets for hmap.oldbuckets.	// The indirection allows to store a pointer to the slice in hiter.	overflow    *[]*bmap	oldoverflow *[]*bmap
	// nextOverflow holds a pointer to a free overflow bucket.	nextOverflow *bmap}