在日常开发中，每位开发人员都会面临连接字符串的任务。在Go语言中，咱们能够运用+操作符、bytes.Buffer、strings.Builder等办法来拼接字符串。
基准测验
为了比照这些办法的功能，我编写了下面的基准测验代码：
package main
import (
"bytes"
"strings"
"testing"
)
func BenchmarkConcat(b *testing.B) {
var str string
for n := 0; n < b.N; n++ {
str += "x"
}
b.StopTimer()
}
func BenchmarkBuffer(b *testing.B) {
var buffer bytes.Buffer
for n := 0; n < b.N; n++ {
buffer.WriteString("x")
}
b.StopTimer()
}
func BenchmarkCopy(b *testing.B) {
bs := make([]byte, b.N)
bl := 0
b.ResetTimer()
for n := 0; n < b.N; n++ {
bl += copy(bs[bl:], "x")
}
b.StopTimer()
}
func BenchmarkBuilder(b *testing.B) {
var str strings.Builder
for n := 0; n < b.N; n++ {
str.WriteString("x")
}
b.StopTimer()
}
在命令行，进入到测验文件地点目录，执行命令：
go test -bench=Benchmark* -benchmem
等待一会，输出测验成果：
BenchmarkConcat-20 1000000 64276 ns/op 503995 B/op 1 allocs/op
BenchmarkBuffer-20 349817613 3.283 ns/op 3 B/op 0 allocs/op
BenchmarkCopy-20 705887335 1.714 ns/op 0 B/op 0 allocs/op
BenchmarkBuilder-20 637184155 2.125 ns/op 5 B/op 0 allocs/op
“
上面的测验成果显现了四种连接字符串的功能。
-
+操作符:
- 执行时间：64,276 纳秒/op
- 内存分配：503,995 字节/op
- 分配次数：1 次/op
剖析：
- 运用
+=运算符进行字符串拼接，它在每次迭代都会创建一个新的字符串，导致较大的内存分配和分配次数。 - 总体而言，这种办法的功能相对较差。
-
bytes.Buffer:
- 执行时间：3.283 纳秒/op
- 内存分配：3 字节/op
- 分配次数：0 次/op
剖析：
- 运用
bytes.Buffer类型，这是一种功能较好的字符串拼接办法。 - 它几乎没有内存分配，而且执行时间十分短，是一种高效的拼接方法。
-
Copy:
- 执行时间：1.714 纳秒/op
- 内存分配：0 字节/op
- 分配次数：0 次/op
剖析：
- 运用
copy函数，直接在预分配的字节数组上进行复制。 - 具有最低的执行时间和零内存分配，是最高效的字符串拼接方法。
-
strings.Builder:
- 执行时间：2.125 纳秒/op
- 内存分配：5 字节/op
- 分配次数：0 次/op
剖析：
- 运用
strings.Builder类型，功能介于bytes.Buffer和copy之间。 - 有一些内存分配，但仍然是一种有用的拼接办法。
总结：
- 在这个基准测验中，
copy函数的功能最佳，其次是bytes.Buffer和strings.Builder，而运用+=运算符的功能最差。 - 在挑选字符串拼接办法时，应根据实际需求和功能要求挑选恰当的方法，避免不必要的内存分配，进步程序执行功率。
- 运用
strings.Builder兼顾了用法和功能，是一种值得推荐的拼接方法。
测验代码
gobyexample/string-concat/string_concat_test.go at master denglei1024/gobyexample (github.com)
