欧美日韩电影一区,国产一区二区网址,亚洲人成在线观看一区二区

主頁 > 知識庫 > Golang 空map和未初始化map的注意事項說明

Golang 空map和未初始化map的注意事項說明

可以對未初始化的map進行取值，但取出來的東西是空：

var m1 map[string]string
fmt.Println(m1["1"])

不能對未初始化的map進行賦值，這樣將會拋出一個異常：

panic: assignment to entry in nil map

var m1 map[string]string
m1["1"] = "1"

通過fmt打印map時，空map和nil map結果是一樣的，都為map[]。所以，這個時候別斷定map是空還是nil，而應該通過map == nil來判斷。

補充：Golang清空map的兩種方式及性能比拼

一、Golang中刪除map的方法

1、所有Go版本通用方法

a := make(map[string]int)
a["a"] = 1
a["b"] = 2
// clear all
a = make(map[string]int)

2. Go 1.11版本以上用法

通過Go的內部函數mapclear方法刪除。這個函數并沒有顯示的調用方法，當你使用for循環遍歷刪除所有元素時，Go的編譯器會優化成Go內部函數mapclear。

package main
func main() {
        m := make(map[byte]int)
        m[1] = 1
        m[2] = 2
        for k := range m {
	        delete(m, k)
        }
}

把上述源代碼直接編譯成匯編（默認編譯是會優化的）：

go tool compile -S map_clear.go

可以看到編譯器把源碼9行的for循環直接優化成了mapclear去刪除所有元素。如下：

再來看看關閉優化后的結果：

go tool compile -l -N -S map_clear.go

關閉優化選項后，Go編譯器直接通過循環遍歷來刪除map里面的元素。

具體的mapclear代碼可以在go源碼庫中runtime/map.go文件中看到，代碼如下：

// mapclear deletes all keys from a map.
func mapclear(t *maptype, h *hmap) {
	if raceenabled  h != nil {
		callerpc := getcallerpc()
		pc := funcPC(mapclear)
		racewritepc(unsafe.Pointer(h), callerpc, pc)
	}
	if h == nil || h.count == 0 {
		return
	}
	if h.flagshashWriting != 0 {
		throw("concurrent map writes")
	}
	h.flags ^= hashWriting
	h.flags ^= sameSizeGrow
	h.oldbuckets = nil
	h.nevacuate = 0
	h.noverflow = 0
	h.count = 0
	// Keep the mapextra allocation but clear any extra information.
	if h.extra != nil {
		*h.extra = mapextra{}
	}
	// makeBucketArray clears the memory pointed to by h.buckets
	// and recovers any overflow buckets by generating them
	// as if h.buckets was newly alloced.
	_, nextOverflow := makeBucketArray(t, h.B, h.buckets)
	if nextOverflow != nil {
		// If overflow buckets are created then h.extra
		// will have been allocated during initial bucket creation.
		h.extra.nextOverflow = nextOverflow
	}
	if h.flagshashWriting == 0 {
		throw("concurrent map writes")
	}
	h.flags ^= hashWriting
}

二、兩種清空map方式性能比較

1、先用benchmark的方式測一下兩種方式

benchmark代碼如下：

func BenchmarkMakeNewMap(b *testing.B) {
	tmpMap := make(map[string]string, 10000)
	for i := 0; i  b.N; i++ {
		for j := 0; j  10000; j++ {
			tmpMap["tmp"+strconv.Itoa(j)] = "tmp"
		}
		tmpMap = make(map[string]string, 10000)
	}
}
func BenchmarkDeleteMap(b *testing.B) {
	tmpMap := make(map[string]string, 10000)
	for i := 0; i  b.N; i++ {
		for j := 0; j  10000; j++ {
			tmpMap["tmp"+strconv.Itoa(j)] = "tmp"
		}
		for k := range tmpMap {
			delete(tmpMap, k)
		}
	}
}

得到測試結果如下：

從測試結果上看，好像確實delete的方式效率更高，但是這個benchmark中總感覺沒有測試到真正清空map的地方，中間穿插著put map的操作，我們用方法2再測一下。

2、單個UT測一下兩種方式

UT代碼如下：

測試過程中禁用了gc，避免gc對運行時間和內存產生干擾。

func TestMakeNewMap(t *testing.T) {
   debug.SetGCPercent(-1)
   var m runtime.MemStats
   tmpMap := make(map[string]string, 1000000)
   for j := 0; j  1000000; j++ {
      tmpMap["tmp"+strconv.Itoa(j)] = "tmp"
   }
   start := time.Now()
   tmpMap = make(map[string]string, 1000000)
   fmt.Println(time.Since(start).Microseconds())
   runtime.ReadMemStats(m)
   fmt.Printf("%d Kb\n", m.Alloc/1024)
}
func TestDeleteMap(t *testing.T) {
   debug.SetGCPercent(-1)
   var m runtime.MemStats
   tmpMap2 := make(map[string]string, 1000000)
   for j := 0; j  1000000; j++ {
      tmpMap2["tmp"+strconv.Itoa(j)] = "tmp"
   }
   start := time.Now()
   for k := range tmpMap2 {
      delete(tmpMap2, k)
   }
   fmt.Println(time.Since(start).Microseconds())
   runtime.ReadMemStats(m)
   fmt.Printf("%d Kb\n", m.Alloc/1024)
}

測試結果如下：