如何在没有加号操作的情况下在 GoLang 中添加字符串？

Question

这可能是重复的，但我无法在任何地方找到正确的答案。 如何在不使用+运算符（被认为很慢）的情况下在 GoLang 中添加字符串？

我知道我可以使用bytes.Buffer附加到字符串，但WriteString只附加。 如果我想prepend ，我必须用后缀字符串写入前缀，如下所示：

package main

import (
    "bytes"
    "fmt"
)

func main() {
    var b bytes.Buffer 
      
    b.WriteString("W") 
    b.WriteString("o") 
    b.WriteString("r") 
    b.WriteString("l") 
    b.WriteString("d") 
   
    var a bytes.Buffer
    a.WriteString("Hello ")
    a.WriteString(b.String())
  
    fmt.Println(a.String()) 
}

有没有更好的办法？

Answer 1

使用strings.Builder是要走的路，如果它在性能关键路径上，否则简单的+非常好：

BenchmarkBuilder-8       7453314           158 ns/op          32 B/op          3 allocs/op
BenchmarkBuffer-8        4411436           273 ns/op         144 B/op          3 allocs/op
BenchmarkPlus-8          3955683           305 ns/op          32 B/op          5 allocs/op

基准：

package main

import (
    "bytes"
    "strings"
    "testing"
)

var r string

func BenchmarkBuilder(b *testing.B) {
    for i := 0; i < b.N; i++ {
        b := new(strings.Builder)
        b.WriteString("W")
        b.WriteString("o")
        b.WriteString("r")
        b.WriteString("l")
        b.WriteString("d")

        a := new(strings.Builder)
        a.WriteString("Hello ")
        a.WriteString(b.String())
        r = a.String()
    }
}
func BenchmarkBuffer(b *testing.B) {
    for i := 0; i < b.N; i++ {
        b := new(bytes.Buffer)
        b.WriteString("W")
        b.WriteString("o")
        b.WriteString("r")
        b.WriteString("l")
        b.WriteString("d")

        a := new(bytes.Buffer)
        a.WriteString("Hello ")
        a.WriteString(b.String())
        r = a.String()
    }
}

func BenchmarkPlus(b *testing.B) {
    for i := 0; i < b.N; i++ {
        b := "W"
        b += "o"
        b += "r"
        b += "l"
        b += "d"

        a := "Hello "
        a += b
        r = a
    }
}

Answer 2

我遇到了需要在前面添加 10,000 个字符串的情况。 这与添加 10 个字符串的最快方法略有不同，但此处尚未回答。

TL;DR 将 10,000 个字符串存储在 []string 中，然后使用 strings.StringBuilder 以相反的顺序组装它。

        var strs []string
        for i := 0; i < 10000; i++ {
            strs = append(strs, "Put your string here")
        }
        var b strings.Builder
        for i := len(strs) - 1; i >= 0; i -= 1 {
            b.WriteString(strs[j])
        }

一种天真的方法+使用了 10 GB 的内存 + 1 秒。 将相当多的时间放入从后面填充缓冲区的自定义前置代码中，将相同的测试用例减少到 10mb + 2 毫秒。 但事实证明，只需存储每个字符串，然后使用字符串构建器就可以用更少的代码实现几乎相同的结果。 （14mb 2.4 毫秒）。 这是基准测试结果：

go test -benchtime=50x -benchmem -bench .
BenchmarkPrepend10kAddition-20                                50         971398162 ns/op        9666950277 B/op    20325 allocs/op
BenchmarkPrepend10kPrepender-20                               50           1924394 ns/op        10165544 B/op      29913 allocs/op
BenchmarkPrepend10kReorderThenStringBuilder-20                50           2436740 ns/op        14518100 B/op      19952 allocs/op

这是代码（没有 prepender 类，因为这需要更多的工作才能公开准备）：

package main

import (
    "strconv"
    "strings"
    "testing"

    "github.com/stretchr/testify/assert"
)

var teststrings []string = []string{
    "Test test tses test test sets etsetsetsetsettesestsetet\n",
    "TEST TEST TEST TEST TEST EST SET ET SET EST EST SET E TSE TES T STE ET SETT\n",
    "ashkajshfksjhdfksjdhfklhjasdfkljhasdfljashdfkljahsdfkjshafdkjashdflkjhsdgkljhsdfklgjhsklfjghksdfjgkldsjfghldksjhfgkdsfjghkdsjhfgkldjsghkldsjfghdklsfgasdjhaksdhjaksdjhasdkjhfksdjhfkjashfdjldhjasfkljashdfkljsahdflkjashdfldhjasfkjsdhf\n",    "asdhakjsdhaksjdhdskajhsdajkshdkajshdkjasdkjdhasfhjadshfashdasgfkjashdgfjhsadgfjashgdfkjhasgdfkjhgasdfkjghasdfkjhgasdkjfhgasdkjghfasdkjghfasdhjfgasjkghfsadhjgfaashkajshfksjhdfksjdhfklhjasdfkljhasdfljashdfkljahsdfkjshafdkjashdflkjhsdgkljhsdfklgjhsklfjghksdfjgkldsjfghldksjhfgkdsfjghkdsjhfgkldjsghkldsjfghdklsfgasdjhaksdhjaksdjhasdkjhfksdjhfkjashfdjldhjasfkljashdfkljsahdflkjashdfldhjasfkjsdhf\n",
    "asdhakjsdhaksjdhdskajhsdajkshdkajshdkjasdkjdhasfhjadshfashdasgfkjashdgfjhsadgfjashgdfkjhasgdfkjhgasdfkjghasdfkjhgasdkjfhgasdkjghfasdkjghfasdhjfgasjkghfsadhjgfaashkajshfksjhdfksjdhfklhjasdfkljhasdfljashdfkljahsdfkjshafdkjashdflkjhsdgkljhsdfklgjhsklfjghksdfjgkldsjfghldksjhfgkdsfjghkdsjhfgkldjsghkldsjfghdklsfgasdjhaksdhjaksdjhasdkjhfksdjhfkjashfdjldhjasfkljashdfkljsahdflkjashdfldhjasfkjsdhf\n",
    "asdhakjsdhaksjdhdskajhsdajkshdkajshdkjasdkjdhasfhjadshfashdasgfkjashdgfjhsadgfjashgdfkjhasgdfkjhgasdfkjghasdfkjhgasdkjfhgasdkjghfasdkjghfasdhjfgasjkghfsadhjgfaashkajshfksjhdfksjdhfklhjasdfkljhasdfljashdfkljahsdfkjshafdkjashdflkjhsdgkljhsdfklgjhsklfjghksdfjgkldsjfghldksjhfgkdsfjghkdsjhfgkldjsghkldsjfghdklsfgasdjhaksdhjaksdjhasdkjhfksdjhfkjashfdjldhjasfkljashdfkljsahdflkjashdfldhjasfkjsdhf\n",
    "asdhakjsdhaksjdhdskajhsdajkshdkajshdkjasdkjdhasfhjadshfashdasgfkjashdgfjhsadgfjashgdfkjhasgdfkjhgasdfkjghasdfkjhgasdkjfhgasdkjghfasdkjghfasdhjfgasjkghfsadhjgfaashkajshfksjhdfksjdhfklhjasdfkljhasdfljashdfkljahsdfkjshafdkjashdflkjhsdgkljhsdfklgjhsklfjghksdfjgkldsjfghldksjhfgkdsfjghkdsjhfgkldjsghkldsjfghdklsfgasdjhaksdhjaksdjhasdkjhfksdjhfkjashfdjldhjasfkljashdfkljsahdflkjashdfldhjasfkjsdhf\n",
    "asdhakjsdhaksjdhdskajhsdajkshdkajshdkjasdkjdhasfhjadshfashdasgfkjashdgfjhsadgfjashgdfkjhasgdfkjhgasdfkjghasdfkjhgasdkjfhgasdkjghfasdkjghfasdhjfgasjkghfsadhjgfaashkajshfksjhdfksjdhfklhjasdfkljhasdfljashdfkljahsdfkjshafdkjashdflkjhsdgkljhsdfklgjhsklfjghksdfjgkldsjfghldksjhfgkdsfjghkdsjhfgkldjsghkldsjfghdklsfgasdjhaksdhjaksdjhasdkjhfksdjhfkjashfdjldhjasfkljashdfkljsahdflkjashdfldhjasfkjsdhf\n",
    "asdhakjsdhaksjdhdskajhsdajkshdkajshdkjasdkjdhasfhjadshfashdasgfkjashdgfjhsadgfjashgdfkjhasgdfkjhgasdfkjghasdfkjhgasdkjfhgasdkjghfasdkjghfasdhjfgasjkghfsadhjgfaashkajshfksjhdfksjdhfklhjasdfkljhasdfljashdfkljahsdfkjshafdkjashdflkjhsdgkljhsdfklgjhsklfjghksdfjgkldsjfghldksjhfgkdsfjghkdsjhfgkldjsghkldsjfghdklsfgasdjhaksdhjaksdjhasdkjhfksdjhfkjashfdjldhjasfkljashdfkljsahdflkjashdfldhjasfkjsdhf\n",
}

func BenchmarkPrepend10kAddition(b *testing.B) {
    for i := 0; i < b.N; i++ {
        str := ""
        for j := 0; j < 10000; j++ {
            str = (strconv.Itoa(j) + teststrings[j%4]) + str
        }
        _ = string(str)
    }
}

func BenchmarkPrepend10kPrepender(b *testing.B) {
    for i := 0; i < b.N; i++ {
        // Example using custom prepender code not included in this post
        prepender := NewStringPrepender()
        for j := 0; j < 10000; j++ {
            prepender.Prepend(strconv.Itoa(j) + teststrings[j%4])
        }
        _ = string(prepender.String())
    }
}

func BenchmarkPrepend10kReorderThenStringBuilder(b *testing.B) {
    for i := 0; i < b.N; i++ {
        // What if we have 10,000 strings and assemble them at the end?
        var strs []string
        for j := 0; j < 10000; j++ {
            strs = append(strs, strconv.Itoa(j)+teststrings[j%4])
        }
        var b strings.Builder
        for j := len(strs) - 1; j >= 0; j -= 1 {
            b.WriteString(strs[j])
        }
        _ = string(b.String())
    }
}

为了在基准测试中生成字符串，我使用 Itoa + 测试字符串列表。 这可能是不必要的，但我添加了它们以确保 []string 中的值不指向相同的内存位置。 随机测试字符串改变连接字符串的长度。