淺談Go語言的高效編碼細節(jié)

更新時間：2023年01月09日 15:07:27 作者：阿兵云原生

這篇文章主要介紹了淺談Go語言的高效編碼細節(jié)，我們都知道golang是天生的高并發(fā)，高效的編譯型語言，可我們也都可知道，工具再好，用法不對，全都白費，我們來舉2個常用路徑來感受一下

struct和map用誰呢

計算量很小的時候，可能看不出使用臨時 struct 和 map 的耗時差距，但是數(shù)量起來了，差距就明顯了，且會隨著數(shù)量越大，差距越發(fā)明顯

當我們遇到鍵和值都可以是固定的時候，我們選擇 struct 比選擇 map 的方式高效多了

我們模擬循環(huán)計算 1 億次，看看使用各自的數(shù)據(jù)結(jié)構(gòu)會耗時多少
循環(huán)前計算一下當前時間
循環(huán)后計算一下當前時間
最后計算兩個時間的差值，此處我們使用毫秒為單位

func main() {
	t1 :=time.Now().UnixNano()/1e6
	for i := 0; i < 100000000; i++ {
		var test struct {
			Name  string
			hobby string
		}
		test.Name = "xiaomotong"
		test.hobby = "program"
	}
	t2 :=time.Now().UnixNano()/1e6
	fmt.Println("t2 - t1 == ", t2-t1)
}

程序運行查看效果：

# go run main.go
t1 ==  1634377149185
t2 ==  1634377149221
t2 - t1 ==  36

使用 struct 的方式，耗時 36 ms ，大家感覺這個時間如何？

我們一起來看看使用 map 的方式吧

func main() {
	t1 :=time.Now().UnixNano()/1e6
	fmt.Println("t1 == ", t1)
	for i := 0; i < 100000000; i++ {
		var test = map[string]interface{}{}
		test["name"] = "xiaomotong"
		test["hobby"] = "program"
	}
	t2 :=time.Now().UnixNano()/1e6
	fmt.Println("t2 == ", t2)
	fmt.Println("t2 - t1 == ", t2-t1)
}

程序運行查看效果：

# go run main.go
t1 == 1634377365927
t2 == 1634377373525
t2 - t1 == 7598

使用 struct 的方式，耗時 7598 ms

使用 map 和使用 struct 的方式，完成同樣數(shù)據(jù)處理，耗時相差 212 倍，就這，我們平時編碼的時候，對于上述的場景，你會選擇哪種數(shù)據(jù)結(jié)構(gòu)呢？

為什么上述差距會那么大，原因是

在我們可以確定字段的情況下，我們使用臨時的 Struct 在運行期間是不需要動態(tài)分配內(nèi)容的，

可是 map 就不一樣，map 還要去檢查索引，這一點就非常耗時了

字符串如何拼接是好

工作中編碼 xdm 遇到字符串拼接的情況，都是如何實現(xiàn)的呢？我們的工具暫時提供如下幾種：

使用 + 的方式
使用 fmt.Sprintf() 的方式
使用 strings.Join 的方式
使用 buffer 的方式

看到這里，也許我們各有各的答案，不過我們還是來實操一遍，看看他們在相同字符串拼接情況下，各自的處理耗時如何

用 + 的方式

我們來計算循環(huán)追加 50 萬次字符串，看看耗時多少

func main() {
	t1 := time.Now().UnixNano() / 1e6
	fmt.Println("t1 == ", t1)
	s := "xiao"
	for i := 0; i < 500000; i++ {
		s += "motong"
	}
	t2 := time.Now().UnixNano() / 1e6
	fmt.Println("t2 == ", t2)
	fmt.Println("t2 - t1 == ", t2-t1)
}

程序運行查看效果：

# go run main.go
t1 == 1634378595642
t2 == 1634378743119
t2 - t1 == 147477

看到這個數(shù)據(jù) xdm 有沒有驚呆了，居然這么慢，耗時 147477 ms 那可是妥妥的 2分27秒呀

Go語言中使用+處理字符串是很消耗性能的，通過數(shù)據(jù)我們就可以看出來

使用 fmt.Sprintf() 的方式

func main() {
	t1 := time.Now().UnixNano() / 1e6
	fmt.Println("t1 == ", t1)
	s := "xiao"
	for i := 0; i < 500000; i++ {
		s = fmt.Sprintf("%s%s",s,"motong")
	}
	t2 := time.Now().UnixNano() / 1e6
	fmt.Println("t2 == ", t2)
	fmt.Println("t2 - t1 == ", t2-t1)
}

程序運行查看效果：

# go run main.go
t1 == 1634378977361
t2 == 1634379240292
t2 - t1 == 262931

看到這個數(shù)據(jù)，咱們也驚呆了，居然耗時 262931 ms，合計 4 分 22秒，xdm 是不是沒有想到使用 fmt.Sprintf 比使用 + 還慢

使用 strings.Join 的方式

func main() {
   t1 := time.Now().UnixNano() / 1e6
   fmt.Println("t1 == ", t1)
   s := []string{}
   s = append(s,"xiao")
   for i := 0; i < 500000; i++ {
      s = append(s ,"motong")
   }
   strings.Join(s,"")
   t2 := time.Now().UnixNano() / 1e6
   fmt.Println("t2 == ", t2)
   fmt.Println("t2 - t1 == ", t2-t1)
}

程序運行查看效果：

# go run main.go
t1 == 1634570001216
t2 == 1634570001294
t2 - t1 == 78

耗時 142923 ms ，合計** 78 ms**

使用 buffer 的方式

使用 buffer 的方式應該說是最好的方式，

func main() {
	t1 := time.Now().UnixNano() / 1e6
	fmt.Println("t1 == ", t1)
	s := bytes.NewBufferString("xiao")
	for i := 0; i < 500000; i++ {
		s.WriteString("motong")
	}
	t2 := time.Now().UnixNano() / 1e6
	fmt.Println("t2 == ", t2)
	fmt.Println("t2 - t1 == ", t2-t1)
}