返回顶部
首页 > 资讯 > 后端开发 > GO >Golong字符串拼接性能优化及原理介绍
  • 919
分享到

Golong字符串拼接性能优化及原理介绍

Go字符串拼接Go字符串拼接原理Go字符串拼接性能 2023-05-14 12:05:45 919人浏览 安东尼
摘要

目录1.字符串高效拼接1.1 常见的字符串拼接1.2 字符串拼接测试1.3 推荐2.相关原理2.1 + 号2.2 strings.Builder 与 bytes.Buffer2.2.

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字符串拼接性能优化及原理介绍的文章就介绍到这了,更多相关Go字符串拼接内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网!

您可能感兴趣的文档:

--结束END--

本文标题: Golong字符串拼接性能优化及原理介绍

本文链接: https://lsjlt.com/news/203092.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

猜你喜欢
软考高级职称资格查询
编程网,编程工程师的家园,是目前国内优秀的开源技术社区之一,形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容,为IT开发者提供了一个发现、使用、并交流开源技术的平台。
  • 官方手机版

  • 微信公众号

  • 商务合作