淺談golang 的高效編碼細節

Posted on by

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 := "xiao"
 for i := 0; i < 500000; i++ {
  s = strings.Join([]string{s,"motong"},"")
 }

 t2 := time.Now().UnixNano() / 1e6
 fmt.Println("t2 == ", t2)
 fmt.Println("t2 - t1 == ", t2-t1)
}

程序運行查看效果：

# go run main.go
t1 ==  1634379455304
t2 ==  1634379598227
t2 – t1 ==  142923

耗時 142923 ms ，合計 2 分 22秒 ，和 使用 +的方式不相上下

使用 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 的方式，需要 142923 ms
  • 第四種，使用 buffer 的方式 ，需要 9ms

使用 buffer 的方式 是 第一種的 16,386 倍 ，是第二種的 29,214 倍 ，是第三種的 15,880 倍

xdm ，如果是遇到上面的場景，你會選擇使用哪一種方式呢

到此這篇關於淺談golang 的高效編碼細節的文章就介紹到這瞭,更多相關golang 高效編碼內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！

推薦閱讀：