Go字符串拼接：copy函数快1000倍

在日常开发中，每位开发人员都会面临连接字符串的任务。在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

“
上面的测验成果显现了四种连接字符串的功能。

1. +操作符:

   • 执行时间：64,276 纳秒/op
   • 内存分配：503,995 字节/op
   • 分配次数：1 次/op

   剖析：

   • 运用 += 运算符进行字符串拼接，它在每次迭代都会创建一个新的字符串，导致较大的内存分配和分配次数。
   • 总体而言，这种办法的功能相对较差。

2. bytes.Buffer:

   • 执行时间：3.283 纳秒/op
   • 内存分配：3 字节/op
   • 分配次数：0 次/op

   剖析：

   • 运用 bytes.Buffer 类型，这是一种功能较好的字符串拼接办法。
   • 它几乎没有内存分配，而且执行时间十分短，是一种高效的拼接方法。

3. Copy:

   • 执行时间：1.714 纳秒/op
   • 内存分配：0 字节/op
   • 分配次数：0 次/op

   剖析：

   • 运用 copy 函数，直接在预分配的字节数组上进行复制。
   • 具有最低的执行时间和零内存分配，是最高效的字符串拼接方法。

4. 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)