864

在 Go 中，astring是一种原始类型，这意味着它是只读的，每次对其进行操作都会创建一个新字符串。

因此，如果我想在不知道结果字符串长度的情况下多次连接字符串，那么最好的方法是什么？

天真的方法是：

var s string
for i := 0; i < 1000; i++ {
    s += getShortStringFromSomewhere()
}
return s

但这似乎不是很有效。

4

19 回答 19

984

新方法：

从 Go 1.10 开始有一种strings.Builder类型，请查看此答案以获取更多详细信息。

旧方式：

使用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) 时间内完成的。

于 2009-11-19T20:31:24.203 回答
417

在 Go 1.10+ 中有strings.Builder, here。

Builder 用于使用 Write 方法有效地构建字符串。它最大限度地减少了内存复制。零值可以使用了。

例子

与 几乎相同bytes.Buffer。

package main

import (
    "strings"
    "fmt"
)

func main() {
    // ZERO-VALUE:
    //
    // It's ready to use from the get-go.
    // You don't need to initialize it.
    var sb strings.Builder

    for i := 0; i < 1000; i++ {
        sb.WriteString("a")
    }

    fmt.Println(sb.String())
}

单击以在操场上查看此内容。

支持的接口

StringBuilder 的方法是在考虑现有接口的情况下实现的。这样您就可以在代码中轻松切换到新的 Builder 类型。

与 bytes.Buffer 的区别

  • 它只能增长或重置。

  • 它有一个内置的 copyCheck 机制，可以防止意外复制它：

    func (b *Builder) copyCheck() { ... }

  • 在bytes.Buffer中，可以像这样访问底层字节(*Buffer).Bytes()：

    • strings.Builder防止这个问题。
    • 有时，这不是问题，而是需要的。
    • 例如：对于将字节传递给io.Reader等时的偷看行为。

  • bytes.Buffer.Reset() 倒带并重用底层缓冲区，而strings.Builder.Reset() 不会，它会分离缓冲区。

笔记

  • 不要复制 StringBuilder 值，因为它会缓存基础数据。
  • 如果要共享 StringBuilder 值，请使用指向它的指针。

在此处查看其源代码以获取更多详细信息。

于 2017-12-13T16:57:00.700 回答
288

如果您知道要预分配的字符串的总长度，那么连接字符串的最有效方法可能是使用内置函数copy。如果您事先不知道总长度，请不要使用copy，而是阅读其他答案。

在我的测试中，这种方法比使用快约 3 倍，比使用bytes.Bufferoperator 快得多（约 12,000 倍）+。此外，它使用更少的内存。

我创建了一个测试用例来证明这一点，结果如下：

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)
    }
}
于 2014-05-25T17:22:27.607 回答
147

如果您有一个想要有效地转换为字符串的字符串切片，那么您可以使用这种方法。否则，请查看其他答案。

字符串包中有一个库函数，名为Join： http: //golang.org/pkg/strings/#Join

查看代码Join显示了与 Append 函数相似的方法 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
于 2009-11-19T14:18:18.430 回答
45

我刚刚在我自己的代码（递归树遍历）中对上面发布的最佳答案进行了基准测试，简单的 concat 运算符实际上比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,"")
}
于 2012-04-29T01:15:00.597 回答
28 
package main

import (
  "fmt"
)

func main() {
    var str1 = "string1"
    var str2 = "string2"
    out := fmt.Sprintf("%s %s ",str1, str2)
    fmt.Println(out)
}
于 2016-03-06T20:35:47.903 回答
25

这是不需要您首先知道或计算整体缓冲区大小的最快解决方案：

var data []byte
for i := 0; i < 1000; i++ {
    data = append(data, getShortStringFromSomewhere()...)
}
return string(data)

根据我的基准，它比复制解决方案慢 20%（每次追加 8.1ns 而不是 6.72ns），但仍比使用 bytes.Buffer 快 55%。

于 2014-08-28T10:46:34.403 回答
24

您可以创建一大片字节并使用字符串切片将短字符串的字节复制到其中。“Effective 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 ( )大字节字节再次将其转换为字符串。

于 2009-11-19T03:57:38.933 回答
24

2018 年添加的注释

从 Go 1.10 开始有一种strings.Builder类型，请查看此答案以获取更多详细信息。

201x 之前的答案

@cd1 的基准代码和其他答案是错误的。b.N不应该在基准函数中设置。由 go test 工具动态设置，判断测试的执行时间是否稳定。

基准函数应该运行相同的测试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

结论：

  1. CopyPreAllocate是最快的方法；AppendPreAllocate非常接近No.1，但更容易编写代码。
  2. Concat在速度和内存使用方面都有非常糟糕的表现。不要使用它。
  3. Buffer#Write并且Buffer#WriteString速度基本相同，与@Dani-Br 在评论中所说的相反。考虑string确实[]byte在 Go 中，这是有道理的。
  4. Copybytes.Buffer 基本上使用与额外簿记和其他东西相同的解决方案。
  5. Copy并Append使用 64 的引导大小，与 bytes.Buffer 相同
  6. Append使用更多的内存和分配，我认为这与它使用的增长算法有关。它的内存增长速度不如 bytes.Buffer

建议：

  1. 对于诸如 OP 想要的简单任务，我会使用Appendor AppendPreAllocate。它足够快且易于使用。
  2. 如果需要同时读写缓冲区，bytes.Buffer当然使用。这就是它的设计目的。
于 2017-04-28T08:03:38.557 回答
14

我原来的建议是

s12 := fmt.Sprint(s1,s2)

但是上面使用bytes.Buffer 的答案 - WriteString()是最有效的方法。

我最初的建议使用反射和类型切换。看到(p *pp) doPrint并(p *pp) printArg
没有基本类型的通用 Stringer() 接口，正如我天真地认为的那样。

至少，Sprint() 在内部使用了 bytes.Buffer。因此

`s12 := fmt.Sprint(s1,s2,s3,s4,...,s1000)`

在内存分配方面是可以接受的。

=> Sprint() 连接可用于快速调试输出。
=> 否则使用 bytes.Buffer ... WriteString

于 2013-07-02T12:51:23.710 回答
11

扩展 cd1 的答案：您可以使用 append() 而不是 copy()。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
于 2015-01-25T02:40:45.700 回答
4

这是@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
于 2017-03-29T08:18:22.783 回答
3

goutils.JoinBetween

 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()
}
于 2018-09-18T03:01:06.570 回答
1

我使用以下方法：-

package main

import (
    "fmt"
    "strings"
)

func main (){
    concatenation:= strings.Join([]string{"a","b","c"},"") //where second parameter is a separator. 
    fmt.Println(concatenation) //abc
}
于 2018-01-26T00:52:48.383 回答
1 
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))
}
于 2018-08-09T09:36:39.647 回答
0

简单易消化的解决方案。评论中的详细信息。复制覆盖切片的元素。我们正在切片单个元素并覆盖它。

package main

import (
    "fmt"
)

var N int = 100000

func main() {
    slice1 := make([]rune, N, N)
    //Efficient with fast performance, Need pre-allocated memory
    //We can add a check if we reached the limit then increase capacity
    //using append, but would be fined for data copying to new array. Also append happens after the length of current slice.
    for i := 0; i < N; i++ {
        copy(slice1[i:i+1], []rune{'N'})
    }
    fmt.Println(slice1)

    //Simple but fast solution, Every time the slice capacity is reached we get a fine of effort that goes
    //in copying data to new array
    slice2 := []rune{}
    for i := 0; i <= N; i++ {
        slice2 = append(slice2, 'N')
    }
    fmt.Println(slice2)

}
于 2021-10-16T12:41:44.587 回答
-1

带有内存分配统计信息的基准测试结果。在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
于 2018-09-05T16:30:42.950 回答
-3 
s := fmt.Sprintf("%s%s", []byte(s1), []byte(s2))
于 2013-09-04T09:34:09.330 回答
-5

strings.Join()来自“字符串”包

如果你有一个类型不匹配（比如如果你试图加入一个 int 和一个字符串），你做 RANDOMTYPE （你想要改变的东西）

前任：

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
于 2016-05-11T00:51:48.193 回答