golang高效拼接字符串的方式

两种方式分别是buffer和array数组方式来拼接。

Buf()方法代表了buffer方式
join方法代表了arrary方式

  1. package csvtomysqlx
  2. import (
  3. "bytes"
  4. "fmt"
  5. "strings"
  6. )
  7. var count1 int64
  8. func getNextString1() (string, bool) {
  9. if count1 < 1000000 {
  10. count1++
  11. return "test", true
  12. }
  13. return "end", false
  14. }
  15. func Buf() {
  16. var buffer bytes.Buffer
  17. for {
  18. if piece, ok := getNextString1(); ok {
  19. buffer.WriteString(piece)
  20. } else {
  21. break
  22. }
  23. }
  24. fmt.Println(len(buffer.String()) / 4)
  25. buffer.Reset()
  26. }
  27. var count2 int64
  28. func getNextString2() (string, bool) {
  29. if count2 < 1000000 {
  30. count2++
  31. return "test", true
  32. }
  33. return "end", false
  34. }
  35. func Join() {
  36. lagerslice := make([]string, 1000)
  37. for {
  38. if piece, ok := getNextString2(); ok {
  39. lagerslice = append(lagerslice, piece)
  40. } else {
  41. break
  42. }
  43. }
  44. join := strings.Join(lagerslice, "")
  45. fmt.Println(len(join) / 4)
  46. fmt.Println(len(lagerslice))
  47. }

测试代码:

  1. package test
  2. import (
  3. "csv/csvtomysqlx"
  4. "testing"
  5. )
  6. func TestBuf(t *testing.T) {
  7. csvtomysqlx.Buf()
  8. }
  9. func TestJoin(t *testing.T) {
  10. csvtomysqlx.Join()
  11. }

测试结果:

说明: 两种方式都是拼接100w个字符串,buffer的速度和array的速度是不在一个量级上的。而且数组的方式会带来更多的开销。所以对于超长的字符串拼接,建议使用buffer的方式。当然如果是少量的拼接。还是用fmt.Sprintf&+=的方式。