Go字符串拼接的方式与性能对比

一、Go中字符串的特殊之处

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

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

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

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

一般的比较运算符（==、!=、<、<=、>=、>）通过在内存中按字节比较来实现字符串的对比。你可以通过函数 len() 来获取字符串所占的字节长度，例如：len(str)。

二、字符串拼接的五种方式

1、字符串拼接符 +

两个字符串 s1 和 s2 可以通过 s := s1 + s2 拼接在一起。

s2 追加在 s1 尾部并生成一个新的字符串 s。

可以通过以下方式来对代码中多行的字符串进行拼接：

str := "Beginning of the string " +
	"second part of the string"

由于编译器行尾自动补全分号的缘故，加号 + 必须放在第一行。

拼接的简写形式 += 也可以用于字符串：

s := "hel" + "lo,"
s += "world!"
fmt.Println(s) //输出 “hello, world!”

但是，在循环中使用加号 + 拼接字符串并不是最高效的做法，更好的办法是使用函数 strings.Join()。

2、使用strings.Join()函数

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

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

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

例如：

func main() {
   s1 := "hello,"
   s2 := "world!"
   join := strings.Join([]string{s1, s2}, "")
   fmt.Println(join) //打印 hello,world!
}

3、使用fmt.Sprintf()函数

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

func main() {
   s1 := "hello,"
   s2 := "world!"
   sprintf := fmt.Sprintf("%s%s", s1, s2)
   fmt.Println(sprintf) //打印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：

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()方法拼接字符串。

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就能避免扩容而创建新的切片了。strings.Builder是非线程安全，性能上和bytes.Buffer不分上下。

三、性能对比

测试代码：

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

当然，具体性能要根据实际使用情况而定。

四、使用建议

使用建议引用自其他博客

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

参考博客：

https://www.jianshu.com/p/df92c0ee6cc8

https://www.cnblogs.com/vinsent/p/11281777.html