xdm，我們都知道 golang 是天生的高併發，高效的編譯型語言
可我們也都可知道，工具再好，用法不對，全都白費，我們來舉 2 個常用路徑來感受一下
struct 和 map 用誰呢？
計算量很小的時候，可能看不出使用 臨時 struct 和 map 的耗時差距，但是數量起來了，差距就明顯了，且會隨著數量越大，差距越發明顯
當我們遇到鍵和值都可以是固定的時候，我們選擇 struct 比 選擇 map 的方式 高效多了
- 我們模擬迴圈計算 1 億 次，看看使用各自的資料結構會耗時多少
- 迴圈前計算一下當前時間
- 迴圈後計算一下當前時間
- 最後計算兩個時間的差值，此處我們使用 毫秒為單位
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 的方式，完成同樣資料處理，耗時相差 212 倍 ， 就這，我們平時編碼的時候，對於上述的場景，你會選擇哪種資料結構呢？
為什麼上述差距會那麼大，原因是
在我們可以確定欄位的情況下，我們使用 臨時的 Struct 在執行期間是不需要動態分配內容的，
可是 map 就不一樣，map 還要去檢查索引，這一點就非常耗時了
字串如何拼接是好？
工作中編碼 xdm 遇到字串拼接的情況，都是如何實現的呢？我們的工具暫時提供如下幾種：
- 使用
+的方式 - 使用
fmt.Sprintf()的方式 - 使用
strings.Join的方式 - 使用
buffer的方式
看到這裡，也許我們各有各的答案，不過我們還是來實操一遍，看看他們在相同字串拼接情況下，各自的處理耗時如何
用 + 的方式
- 我們來計算迴圈追加 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看到這個資料 xdm 有沒有驚呆了，居然這麼慢，耗時 147477 ms 那可是妥妥的 2分27秒呀
Go語言 中使用+處理字串是很消耗效能的，透過資料我們就可以看出來
使用 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看到這個資料，我們們也驚呆了，居然耗時 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)
}# go run main.go
t1 == 1634378506021
t2 == 1634378506030
t2 - t1 == 9透過上面的資料，我們看到，拼接同樣 50 萬次的資料
- 第一種，使用
+的方式 ，需要 147477 ms - 第二種，使用
fmt.Sprintf()的方式，需要 262931 ms - 第三種，使用
strings.Join的方式，需要 78 ms - 第四種，使用
buffer的方式 ，需要 9ms
使用 buffer 的方式 是 第一種的 16,386 倍 ，是第二種的 29,214 倍 ，是第三種的 8 倍多
xdm ，如果是遇到上面的場景，你會選擇使用哪一種方式呢，評論區可以一起討論一下，是否還有更高效的方式
歡迎點贊，關注，收藏
朋友們，你的支援和鼓勵，是我堅持分享，提高質量的動力
好了，本次就到這裡
技術是開放的，我們的心態，更應是開放的。擁抱變化，向陽而生，努力向前行。
我是阿兵雲原生，歡迎點贊關注收藏，下次見~