Go随笔 | 字符串拼接性能 | 闪电侠的小黑板

Go中的字符串

Go中的字符串是 UTF-8 字符的一个序列（当字符为 ASCII 码时则占用 1 个字节，其它字符根据需要占用 2-4 个字节）。由于该编码对占用字节长度的不定性，Go 中的字符串里面的字符也可能根据需要占用 1 至 4 个字节，这与其它语言如 C++、Java 或者 Python 不同（Java 始终使用 2 个字节）。Go 这样做的好处是不仅减少了内存和硬盘空间占用，同时也不用其它语言那样需要对使用 UTF-8 字符集的文本进行编码和解码。

字符串是一种值类型，且值不可变，即创建某个文本后你无法再次修改这个文本的内容；更深入地讲，字符串是字节的定长数组。

1
2
3
4
5


// go字符串底层数据结构
type StringHeader struct {
	Data uintptr // 字符串指向的底层字节数组
	Len  int     // 字符串的字节的长度
}

和 C/C++不一样，Go 中的字符串是根据长度限定，而非特殊字符\0。string 类型的零值为长度为零的字符串，即空字符串 “"。

一般的比较运算符（==、!=、<、<=、>=、>）通过在内存中按字节比较来实现字符串的对比。

字符串拼接的常见方法

1、字符串拼接符 +

两个字符串 s1 和 s2 可以通过 s := s1 + s2 拼接在一起。s2 追加在 s1 尾部并生成一个新的字符串 s。但是，在循环中使用加号 + 拼接字符串并不是最高效的做法，更好的办法是使用函数 strings.Join()。

2、使用strings.Join()函数

go的strings包为字符串的拼接提供了一个方法

1

func Join(a []string, sep string) string

Join 用于将元素类型为string的切片使用分割符号sep来拼接组成一个字符串。

3、使用fmt.Sprintf()函数

Sprintf()函数可以将格式化后的字符串以返回值的形式返回。

1
2
3
4
5
6


func main() {
   s1 := "hello,"
   s2 := "world!"
   s := fmt.Sprintf("%s%s", s1, s2)
   fmt.Println(s) // 打印 hello,world!
}

内部使用[]byte实现，不像直接运算符这种会产生很多临时的字符串，但是内部的逻辑比较复杂，有很多额外的判断，还用到了interface，所以性能也不是很好。

4、使用buffer.WriteString()方法

bytes包中的Buffer类（类似于Java的StringBuilder类）提供了一个方法：

func (b *Buffer) WriteString(s string) (n int, err error)

在下面的代码段中，我们创建一个 buffer，通过 buffer.WriteString(s) 方法将字符串 s 追加到后面，最后再通过 buffer.String() 方法转换为string：

1
2
3
4
5
6
7
8


func main() {
	s1 := "hello,"
	s2 := "world!"
	var buf bytes.Buffer
	buf.WriteString(s1)
	buf.WriteString(s2)
	fmt.Println(buf.String()) // 输出 hello,world!
}

这种实现方式比使用 += 要更节省内存和 CPU，尤其是要串联的字符串数目特别多的时候。如果能预估字符串的长度，还可以用buffer.Grow()方法来设置 cap。

5、使用Builder.WriterString()方法

与bytes类似，strings包中存在的Builder类提供一个方法：

func (b *Builder) WriteString(s string) (int, error)

下列代码，使用Builder.WriterString()方法拼接字符串。

1
2
3
4
5
6


func main() {
   var buf strings.Builder
   buf.WriteString("hello,")
   buf.WriteString("world")
   fmt.Println(buf.String()) // 输出 hello,world
}

strings.Builder同样也提供了Grow()来支持预定义容量。其内部通过切片来保存和管理内容。当我们可以预定义我们需要使用的容量时，strings.Builder就能避免扩容而创建新的切片了。strings.Builder是非线程安全，性能上和bytes.Buffer不分上下。

性能对比

下面用一个简单的例子来测试不同用法的性能。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46


func JoinString() {
   var loop = 300000
   var s string
   aim := "w"
   var start time.Time
   //拼接符+连接==================================
   s = ""
   start = time.Now()
   for i := 0; i < loop; i++ {
      s += aim
   }
   fmt.Printf("len(s):%d,拼接符方法:%v\n", len(s), time.Since(start))
   //strings.Join连接==================================
   s = ""
   start = time.Now()
   v := []string{s, aim}
   for i := 0; i < loop; i++ {
      s = strings.Join(v, "")
   }
   fmt.Printf("len(s):%d,strings.Join方法:%v\n", len(s), time.Since(start))
   //buffer.WriterString方法==================================
   s = ""
   start = time.Now()
   var buf bytes.Buffer
   for i := 0; i < loop; i++ {
      buf.WriteString(aim)
   }
   s = buf.String()
   fmt.Printf("len(s):%d,buffer.WriterString方法:%v\n", len(s), time.Since(start))
   //Builder.WriterString方法==================================
   s = ""
   start = time.Now()
   var builder strings.Builder
   for i := 0; i < loop; i++ {
      builder.WriteString(aim)
   }
   s = builder.String()
   fmt.Printf("len(s):%d,Builder.WriterString方法:%v\n", len(s), time.Since(start))
   //fmt.Sprintf方法==================================
   s = ""
   start = time.Now()
   for i := 0; i < loop; i++ {
      s = fmt.Sprintf("%s%s", s, aim)
   }
   fmt.Printf("len(s):%d,fmt.Sprintf方法:%v\n", len(s), time.Since(start))
}

测试结果如下：

len(s):300000---------拼接符方法-----------------------------3.7244467s
len(s):1--------------strings.Join方法----------------------6.9228ms
len(s):300000---------buffer.WriterString方法---------------1.5602ms
len(s):300000---------Builder.WriterString方法--------------528.9µs
len(s):300000---------fmt.Sprintf方法-----------------------7.7673889s

简单得出如下性能优劣结论：

Builder.WriterString > buffer.WriterString > strings.Join > 拼接符方法 > fmt.Sprintf

使用建议

使用建议引用自其他博客，看下面4条：

在已有字符串数组的场合，使用strings.Join()能有比较好的性能
在一些性能要求较高的场合，尽量使用buffer.WriteString()或Builder.WriterString()以获得更好的性能
性能要求不太高的场合，直接使用运算符，代码更简短清晰，能获得比较好的可读性
如果需要拼接的不仅仅是字符串，还有数字之类的其他需求的话，可以考虑fmt.Sprintf()

https://www.flysnow.org/2018/11/05/golang-concat-strings-performance-analysis

https://www.flysnow.org/2018/11/11/golang-concat-strings-performance-analysis

（完）

系列文章导航

Go随笔 | 字符串拼接性能