Golong字符串拼接性能优化方法及原理是什么

这篇文章主要介绍了Golong字符串拼接性能优化方法及原理是什么的相关知识，内容详细易懂，操作简单快捷，具有一定借鉴价值，相信大家阅读完这篇Golong字符串拼接性能优化方法及原理是什么文章都会有所收获，下面我们一起来看看吧。

1.字符串高效拼接

go 字符串是不可修改的，所谓字符串拼接就是创建新的字符串对象。如果代码中存在大量的字符串拼接，那么性能将会存在影响。

1.1 常见的字符串拼接

+号

func plusConcat(n int, s string) string {
	var d string
	for i := 0; i < n; i++ {
		d += s
	}
	return d
}

格式化

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

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

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

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

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 字符串拼接测试

定义一个随机字符串生成函数：

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中字符串拼接函数进行基准测试：

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方法，特殊情况下避免多次内存分配。

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() 方法：

func (b *Buffer) String() string {
	if b == nil {
		// Special case, useful in debugging.
		return "<nil>"
	}
	return string(b.buf[b.off:])
}

Builder 的String() 方法：

// 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字符串拼接性能优化方法及原理是什么”这篇文章的内容就介绍到这里，感谢各位的阅读！相信大家对“Golong字符串拼接性能优化方法及原理是什么”知识都有一定的了解，大家如果还想学习更多知识，欢迎关注亿速云行业资讯频道。