1.字符串高效拼接
go 字符串是不可修改的，所谓字符串拼接就是创建新的字符串对象。如果代码中存在大量的字符串拼接，那么性能将会存在影响。
1.1 常见的字符串拼接
+号
|
1
2
3
4
5
6
7
|
func plusConcat(n int, s string) string { var d string for i := 0; i < n; i++ { d += s } return d} |
格式化
|
1
2
3
4
5
6
7
|
func sprintfConcat(n int, s string) string { var d string for i := 0; i < n; i++ { d = fmt.Sprintf("%s%s", d, s) } return d} |
strings.Builder
|
1
2
3
4
5
6
7
|
func builderConcat(n int, s string) string { var sb = new(strings.Builder) for i := 0; i < n; i++ { sb.WriteString(s) } return sb.String()} |
bytes.Buffer
|
1
2
3
4
5
6
7
|
func bufferConcat(n int, s string) string { var bb = new(bytes.Buffer) for i := 0; i < n; i++ { bb.WriteString(s) } return bb.String()} |
[]byte
|
1
2
3
4
5
6
7
|
func byteConcat(n int, s string) string { var b = make([]byte, 0) for i := 0; i < n; i++ { b = append(b, s...) } return string(b)} |
预分配[]byte
|
1
2
3
4
5
6
7
|
func preByteConcat(n int, s string) string { var b = make([]byte, 0, n*len(s)) for i := 0; i < n; i++ { b = append(b, s...) } return string(b)} |
1.2 字符串拼接测试
定义一个随机字符串生成函数：
|
1
2
3
4
5
6
7
8
|
const letterBytes = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"func randomString(n int) string { b := make([]byte, n) for i := range b { b[i] = letterBytes[rand.Intn(len(letterBytes))] } return string(b)} |
对上述6中字符串拼接函数进行基准测试：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
func benchmark(b *testing.B, f func(int, string) string) { var str = randomString(10) for i := 0; i < b.N; i++ { f(10000, str) }}func BenchmarkPlusConcat(b *testing.B) { benchmark(b, plusConcat) }func BenchmarkSprintfConcat(b *testing.B) { benchmark(b, sprintfConcat) }func BenchmarkBuilderConcat(b *testing.B) { benchmark(b, builderConcat) }func BenchmarkBufferConcat(b *testing.B) { benchmark(b, bufferConcat) }func BenchmarkByteConcat(b *testing.B) { benchmark(b, byteConcat) }func BenchmarkPreByteConcat(b *testing.B) { benchmark(b, preByteConcat) } |
go test -bench=. test/string -benchmem
毫无疑问 + 和 格式化 两种方式最耗时，且内存分配还多。
性能最好的是预分配[]byte方式，它只进行两次内存分配，其余部分全部在进行内存拷贝操作。
其次是strings.builder
然后是bytes.buffer
紧接着是 []byte方式
1.3 推荐
一般来说，选择使用string.Builder方式来进行拼接。
其次，strings.Builder 提供了 Grow方法，特殊情况下避免多次内存分配。
|
1
2
3
4
5
6
7
8
|
func builderConcat(n int, s string) string { var sb = new(strings.Builder) sb.Grow(n * len(s)) for i := 0; i < n; i++ { sb.WriteString(s) } return sb.String()} |
然后Builder 再与 预分配的[]byte 比较：
得出：builder 比 预分配[]byte 少一次内存分配，当然内存使用也会少一半。
2.相关原理
2.1 + 号
+ 性能如此差是因为go 字符串本省不可修改，两个字符串拼接，那么新构造一个字符串，长度等与两个字符串长度之和，然后分别将两个字符串的内容拷贝到新的字符串中。且如果连续的字符串拼接，就像plusConcat函数,会产生大量临时对象d,对GC也是一种压力。
2.2 strings.Builder 与 bytes.Buffer
2.2.1 内部[]byte 增长方式：
strings.Builder 内部采用[]byte存储,初始大小为0，每次写入是按go 默认切片增长方式拓展底层[]byte的长度。
bytes.Buffer 内存采用[]byte,其内部有控制增长的算法，最小申请空间就为64bytes,在写入为超过一倍的情况下，是按1一倍空间增加。
64 128 256 512 1024 2048 4096 8192 16384 32768 65536 131072 262144 ...
2.2.2 性能比较
为啥 Buffer 比 Builder 多一次内存分配：
Buffer 的String() 方法：
|
1
2
3
4
5
6
7
|
func (b *Buffer) String() string { if b == nil { // Special case, useful in debugging. return "<nil>" } return string(b.buf[b.off:])} |
Builder 的String() 方法：
|
1
2
3
4
|
// String returns the accumulated string.func (b *Builder) String() string { return unsafe.String(unsafe.SliceData(b.buf), len(b.buf))} |
可以看出，Buffer在转字符串时，需要重新构造string对象；而Builder 返回的string 对象则直接复用Builder 底层的buf。
到此这篇关于Golong字符串拼接性能优化及原理介绍的文章就介绍到这了,更多相关Go字符串拼接内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！
原文链接：https://blog.csdn.net/qq_42170897/article/details/129869260
