题
在 Go 中,一个 string
是一种原始类型,这意味着它是只读的,并且对它的每次操作都会创建一个新字符串。
因此,如果我想多次连接字符串而不知道结果字符串的长度,最好的方法是什么?
天真的方法是:
s := ""
for i := 0; i < 1000; i++ {
s += getShortStringFromSomewhere()
}
return s
但这似乎效率不高。
解决方案
2018年添加注释
从 Go 1.10 开始有一个 strings.Builder
类型, 请看一下这个答案以了解更多详细信息.
201x 之前的答案
最好的方法是使用 bytes
包裹。它有一个 Buffer
实现的类型 io.Writer
.
package main
import (
"bytes"
"fmt"
)
func main() {
var buffer bytes.Buffer
for i := 0; i < 1000; i++ {
buffer.WriteString("a")
}
fmt.Println(buffer.String())
}
这在 O(n) 时间内完成。
其他提示
的字符串连接的最有效方式是使用内置函数 copy
。在我的测试,这种方法是〜3倍比使用更快的 bytes.Buffer
和多快得多(〜12,000 x)的比使用操作者+
。此外,它使用更少的内存。
我创建测试用例来证明这一点,这里的结果:
BenchmarkConcat 1000000 64497 ns/op 502018 B/op 0 allocs/op
BenchmarkBuffer 100000000 15.5 ns/op 2 B/op 0 allocs/op
BenchmarkCopy 500000000 5.39 ns/op 0 B/op 0 allocs/op
以下是用于测试代码:
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()
if s := strings.Repeat("x", b.N); str != s {
b.Errorf("unexpected result; got=%s, want=%s", str, s)
}
}
func BenchmarkBuffer(b *testing.B) {
var buffer bytes.Buffer
for n := 0; n < b.N; n++ {
buffer.WriteString("x")
}
b.StopTimer()
if s := strings.Repeat("x", b.N); buffer.String() != s {
b.Errorf("unexpected result; got=%s, want=%s", buffer.String(), s)
}
}
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()
if s := strings.Repeat("x", b.N); string(bs) != s {
b.Errorf("unexpected result; got=%s, want=%s", string(bs), s)
}
}
// Go 1.10
func BenchmarkStringBuilder(b *testing.B) {
var strBuilder strings.Builder
b.ResetTimer()
for n := 0; n < b.N; n++ {
strBuilder.WriteString("x")
}
b.StopTimer()
if s := strings.Repeat("x", b.N); strBuilder.String() != s {
b.Errorf("unexpected result; got=%s, want=%s", strBuilder.String(), s)
}
}
从 Go 1.10 开始有一个 strings.Builder
, 这里.
Builder 用于使用 Write 方法有效地构建字符串。它最大限度地减少了内存复制。零值即可使用。
用法:
几乎与 bytes.Buffer
.
package main
import (
"strings"
"fmt"
)
func main() {
var str strings.Builder
for i := 0; i < 1000; i++ {
str.WriteString("a")
}
fmt.Println(str.String())
}
笔记: 不要复制 StringBuilder 值,因为它会缓存基础数据。如果要共享 StringBuilder 值,请使用指针。
StringBuilder支持的方法和接口:
它的方法是在考虑现有接口的情况下实现的,以便您可以在代码中轻松切换到新的构建器。
- 成长(整数) -> bytes.Buffer#Grow
- Len() 整数 -> 字节.Buffer#Len
- 重置() -> bytes.Buffer#重置
- String() 字符串 -> fmt.斯金格
- 写入([]字节)(整数,错误) -> io.Writer
- WriteByte(字节)错误 -> io.ByteWriter
- WriteRune(符文)(整数,错误) -> bufio.Writer#WriteRune - bytes.Buffer#WriteRune
- WriteString(字符串)(整数,错误) -> io.stringWriter
零值使用:
var buf strings.Builder
与 bytes.Buffer 的区别:
它只能增长或重置。
在
bytes.Buffer
, ,可以像这样访问底层字节:(*Buffer).Bytes()
;strings.Builder
防止这个问题。有时,这不是问题,而是需要的(例如,当字节传递给io.Reader
ETC)。它还内置了复制检查机制,可以防止意外复制(
func (b *Builder) copyCheck() { ... }
).
查看它的源代码 这里.
有在包串称为Join
库函数:
http://golang.org/pkg/strings/#Join
一看Join
的代码显示了一个类似的方法来附加功能Kinopiko写道: HTTPS ://golang.org/src/strings/strings.go#L420
用法:
import (
"fmt";
"strings";
)
func main() {
s := []string{"this", "is", "a", "joined", "string\n"};
fmt.Printf(strings.Join(s, " "));
}
$ ./test.bin
this is a joined string
我只是基准以上我自己的代码顶贴的答案(递归遍历树)和简单的毗连运算速度居然比BufferString
。
func (r *record) String() string {
buffer := bytes.NewBufferString("");
fmt.Fprint(buffer,"(",r.name,"[")
for i := 0; i < len(r.subs); i++ {
fmt.Fprint(buffer,"\t",r.subs[i])
}
fmt.Fprint(buffer,"]",r.size,")\n")
return buffer.String()
}
此花0.81秒,而以下代码:
func (r *record) String() string {
s := "(\"" + r.name + "\" ["
for i := 0; i < len(r.subs); i++ {
s += r.subs[i].String()
}
s += "] " + strconv.FormatInt(r.size,10) + ")\n"
return s
}
只用了0.61秒。这可能是由于在创建新BufferString
的开销。
<强>更新:强>我还基准的join
函数并将其在0.54秒跑
func (r *record) String() string {
var parts []string
parts = append(parts, "(\"", r.name, "\" [" )
for i := 0; i < len(r.subs); i++ {
parts = append(parts, r.subs[i].String())
}
parts = append(parts, strconv.FormatInt(r.size,10), ")\n")
return strings.Join(parts,"")
}
您可以创建一个字节的一大截,用串片的短字符串的字节复制到它。有在“有效Go”的给定的一个函数:
func Append(slice, data[]byte) []byte {
l := len(slice);
if l + len(data) > cap(slice) { // reallocate
// Allocate double what's needed, for future growth.
newSlice := make([]byte, (l+len(data))*2);
// Copy data (could use bytes.Copy()).
for i, c := range slice {
newSlice[i] = c
}
slice = newSlice;
}
slice = slice[0:l+len(data)];
for i, c := range data {
slice[l+i] = c
}
return slice;
}
然后,当操作完成后,使用上的字节的大截string ( )
再次将其转换成一个字符串。
这是不需要的最快的解决方案 你知道或第一计算总缓冲器大小:
var data []byte
for i := 0; i < 1000; i++ {
data = append(data, getShortStringFromSomewhere()...)
}
return string(data)
通过我的基准时,它比溶液拷贝慢20%(每8.1ns 附加而非6.72ns),但仍比使用bytes.Buffer快55%。
package main
import (
"fmt"
)
func main() {
var str1 = "string1"
var str2 = "string2"
out := fmt.Sprintf("%s %s ",str1, str2)
fmt.Println(out)
}
2018年添加注释
从 Go 1.10 开始有一个 strings.Builder
类型, 请看一下这个答案以了解更多详细信息.
201x 之前的答案
@cd1和其他答案的基准代码是错误的。 b.N
不应在基准函数中设置。它由go测试工具动态设置,以确定测试的执行时间是否稳定。
基准测试函数应该运行相同的测试 b.N
每次迭代的时间和循环内的测试应该相同。所以我通过添加内循环来修复它。我还添加了一些其他解决方案的基准:
package main
import (
"bytes"
"strings"
"testing"
)
const (
sss = "xfoasneobfasieongasbg"
cnt = 10000
)
var (
bbb = []byte(sss)
expected = strings.Repeat(sss, cnt)
)
func BenchmarkCopyPreAllocate(b *testing.B) {
var result string
for n := 0; n < b.N; n++ {
bs := make([]byte, cnt*len(sss))
bl := 0
for i := 0; i < cnt; i++ {
bl += copy(bs[bl:], sss)
}
result = string(bs)
}
b.StopTimer()
if result != expected {
b.Errorf("unexpected result; got=%s, want=%s", string(result), expected)
}
}
func BenchmarkAppendPreAllocate(b *testing.B) {
var result string
for n := 0; n < b.N; n++ {
data := make([]byte, 0, cnt*len(sss))
for i := 0; i < cnt; i++ {
data = append(data, sss...)
}
result = string(data)
}
b.StopTimer()
if result != expected {
b.Errorf("unexpected result; got=%s, want=%s", string(result), expected)
}
}
func BenchmarkBufferPreAllocate(b *testing.B) {
var result string
for n := 0; n < b.N; n++ {
buf := bytes.NewBuffer(make([]byte, 0, cnt*len(sss)))
for i := 0; i < cnt; i++ {
buf.WriteString(sss)
}
result = buf.String()
}
b.StopTimer()
if result != expected {
b.Errorf("unexpected result; got=%s, want=%s", string(result), expected)
}
}
func BenchmarkCopy(b *testing.B) {
var result string
for n := 0; n < b.N; n++ {
data := make([]byte, 0, 64) // same size as bootstrap array of bytes.Buffer
for i := 0; i < cnt; i++ {
off := len(data)
if off+len(sss) > cap(data) {
temp := make([]byte, 2*cap(data)+len(sss))
copy(temp, data)
data = temp
}
data = data[0 : off+len(sss)]
copy(data[off:], sss)
}
result = string(data)
}
b.StopTimer()
if result != expected {
b.Errorf("unexpected result; got=%s, want=%s", string(result), expected)
}
}
func BenchmarkAppend(b *testing.B) {
var result string
for n := 0; n < b.N; n++ {
data := make([]byte, 0, 64)
for i := 0; i < cnt; i++ {
data = append(data, sss...)
}
result = string(data)
}
b.StopTimer()
if result != expected {
b.Errorf("unexpected result; got=%s, want=%s", string(result), expected)
}
}
func BenchmarkBufferWrite(b *testing.B) {
var result string
for n := 0; n < b.N; n++ {
var buf bytes.Buffer
for i := 0; i < cnt; i++ {
buf.Write(bbb)
}
result = buf.String()
}
b.StopTimer()
if result != expected {
b.Errorf("unexpected result; got=%s, want=%s", string(result), expected)
}
}
func BenchmarkBufferWriteString(b *testing.B) {
var result string
for n := 0; n < b.N; n++ {
var buf bytes.Buffer
for i := 0; i < cnt; i++ {
buf.WriteString(sss)
}
result = buf.String()
}
b.StopTimer()
if result != expected {
b.Errorf("unexpected result; got=%s, want=%s", string(result), expected)
}
}
func BenchmarkConcat(b *testing.B) {
var result string
for n := 0; n < b.N; n++ {
var str string
for i := 0; i < cnt; i++ {
str += sss
}
result = str
}
b.StopTimer()
if result != expected {
b.Errorf("unexpected result; got=%s, want=%s", string(result), expected)
}
}
环境为 OS X 10.11.6、2.2 GHz Intel Core i7
检测结果:
BenchmarkCopyPreAllocate-8 20000 84208 ns/op 425984 B/op 2 allocs/op
BenchmarkAppendPreAllocate-8 10000 102859 ns/op 425984 B/op 2 allocs/op
BenchmarkBufferPreAllocate-8 10000 166407 ns/op 426096 B/op 3 allocs/op
BenchmarkCopy-8 10000 160923 ns/op 933152 B/op 13 allocs/op
BenchmarkAppend-8 10000 175508 ns/op 1332096 B/op 24 allocs/op
BenchmarkBufferWrite-8 10000 239886 ns/op 933266 B/op 14 allocs/op
BenchmarkBufferWriteString-8 10000 236432 ns/op 933266 B/op 14 allocs/op
BenchmarkConcat-8 10 105603419 ns/op 1086685168 B/op 10000 allocs/op
结论:
CopyPreAllocate
是最快的方法;AppendPreAllocate
与No.1相当接近,但代码编写起来更容易。Concat
在速度和内存使用方面都有非常糟糕的表现。不要使用它。Buffer#Write
和Buffer#WriteString
速度基本相同,与@Dani-Br 在评论中所说的相反。考虑到string
确实是[]byte
在 Go 中,这是有道理的。- bytes.Buffer 基本上使用相同的解决方案
Copy
有额外的簿记和其他东西。 Copy
和Append
使用 64 的引导程序大小,与 bytes.Buffer 相同Append
使用更多的内存和分配,我认为这与它使用的增长算法有关。它的内存增长速度不如 bytes.Buffer
建议:
- 对于简单的任务,比如OP想要的,我会使用
Append
或者AppendPreAllocate
. 。它足够快并且易于使用。 - 如果需要同时读取和写入缓冲区,请使用
bytes.Buffer
当然。这就是它的设计目的。
我原来建议是
s12 := fmt.Sprint(s1,s2)
但是以上回答使用 bytes.Buffer - WriteString()是最有效的方式。
我的初始建议使用反射和类型开关。 见(p *pp) doPrint
和(p *pp) printArg
结果
没有普遍纵梁()接口,用于基本类型,因为我曾天真地以为。
至少虽然,Sprint公司()内部使用bytes.Buffer。因此
`s12 := fmt.Sprint(s1,s2,s3,s4,...,s1000)`
是可接受的,存储器分配的条款。
=>冲刺()级联可用于快速调试输出。结果, =>否则,使用bytes.Buffer ... WriteString
扩展在CD1的回答: 您可以使用的append(),而不是复制()。 追加()使越来越大进步规定,花费多一点的内存,但节省了时间。 我加入两个基准,而你的页首。 与本地运行
go test -bench=. -benchtime=100ms
在我的ThinkPad T400s的它产生:
BenchmarkAppendEmpty 50000000 5.0 ns/op
BenchmarkAppendPrealloc 50000000 3.5 ns/op
BenchmarkCopy 20000000 10.2 ns/op
这是通过@ CD1(Go 1.8
,linux x86_64
)与缺陷的由@icza和@PickBoy提到的修复提供基准的实际版本。
Bytes.Buffer
是经由7
操作者只+
倍比直接字符串连接更快。
package performance_test
import (
"bytes"
"fmt"
"testing"
)
const (
concatSteps = 100
)
func BenchmarkConcat(b *testing.B) {
for n := 0; n < b.N; n++ {
var str string
for i := 0; i < concatSteps; i++ {
str += "x"
}
}
}
func BenchmarkBuffer(b *testing.B) {
for n := 0; n < b.N; n++ {
var buffer bytes.Buffer
for i := 0; i < concatSteps; i++ {
buffer.WriteString("x")
}
}
}
时序:
BenchmarkConcat-4 300000 6869 ns/op
BenchmarkBuffer-4 1000000 1186 ns/op
func JoinBetween(in []string, separator string, startIndex, endIndex int) string {
if in == nil {
return ""
}
noOfItems := endIndex - startIndex
if noOfItems <= 0 {
return EMPTY
}
var builder strings.Builder
for i := startIndex; i < endIndex; i++ {
if i > startIndex {
builder.WriteString(separator)
}
builder.WriteString(in[i])
}
return builder.String()
}
我它使用执行以下操作: -
package main
import (
"fmt"
"strings"
)
func main (){
concatenation:= strings.Join([]string{"a","b","c"},"") //where second parameter is a separator.
fmt.Println(concatenation) //abc
}
package main
import (
"fmt"
)
func main() {
var str1 = "string1"
var str2 = "string2"
result := make([]byte, 0)
result = append(result, []byte(str1)...)
result = append(result, []byte(str2)...)
result = append(result, []byte(str1)...)
result = append(result, []byte(str2)...)
fmt.Println(string(result))
}
内存分配统计基准测试结果。在 github上。
使用strings.Builder以优化性能。强>
go test -bench . -benchmem
goos: darwin
goarch: amd64
pkg: github.com/hechen0/goexp/exps
BenchmarkConcat-8 1000000 60213 ns/op 503992 B/op 1 allocs/op
BenchmarkBuffer-8 100000000 11.3 ns/op 2 B/op 0 allocs/op
BenchmarkCopy-8 300000000 4.76 ns/op 0 B/op 0 allocs/op
BenchmarkStringBuilder-8 1000000000 4.14 ns/op 6 B/op 0 allocs/op
PASS
ok github.com/hechen0/goexp/exps 70.071s
s := fmt.Sprintf("%s%s", []byte(s1), []byte(s2))
从 “字符串” 包strings.Join()
如果你有一个类型不匹配(例如,如果你想加入一个int和一个字符串),你做RANDOMTYPE(你想要的东西改变)
EX:
package main
import (
"fmt"
"strings"
)
var intEX = 0
var stringEX = "hello all you "
var stringEX2 = "people in here"
func main() {
s := []string{stringEX, stringEX2}
fmt.Println(strings.Join(s, ""))
}
<强>输出:强>
hello all you people in here