Como concatenar cordas com eficiência

No Go, a stringé um tipo primitivo, o que significa que é somente leitura, e toda manipulação dele criará uma nova string.

Portanto, se eu quiser concatenar seqüências de caracteres várias vezes sem saber o tamanho da sequência resultante, qual é a melhor maneira de fazer isso?

A maneira ingênua seria:

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

mas isso não parece muito eficiente.

Nova maneira:

No Go 1.10, existe um strings.Buildertipo, consulte esta resposta para obter mais detalhes .

À moda antiga:

Use o bytespacote. Tem um Buffertipo que implementa 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())
}

Isso é feito em O (n) tempo.

A maneira mais eficiente de concatenar seqüências de caracteres é usando a função interna copy. Nos meus testes, essa abordagem é ~ 3x mais rápida que o uso bytes.Buffere muito mais rápida (~ 12.000x) do que o operador +. Além disso, ele usa menos memória.

Eu criei um caso de teste para provar isso e aqui estão os resultados:

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

Abaixo está o código para teste:

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)
    }
}

Em Go 1.10+ existe strings.Builder, aqui .

Um Construtor é usado para construir eficientemente uma sequência usando métodos Write. Minimiza a cópia da memória. O valor zero está pronto para uso.

Exemplo

É quase o mesmo com 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 str strings.Builder

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

    fmt.Println(str.String())
}

Clique para ver isso no playground .

Nota

• Não copie um valor StringBuilder, pois ele armazena em cache os dados subjacentes.
• Se você deseja compartilhar um valor StringBuilder, use um ponteiro para ele.

Interfaces Suportadas

Os métodos do StringBuilder estão sendo implementados com as interfaces existentes em mente. Para que você possa alternar facilmente para o novo tipo de construtor em seu código.

• Crescer (int) -> bytes.Buffer # Crescer
• Len () int -> bytes.Buffer # Len
• Reset () -> bytes.Buffer # Reset
• String () string -> fmt.Stringer
• Write ([] byte) (int, erro) -> io.Writer
• Erro WriteByte (byte) -> io.ByteWriter
• WriteRune (rune) (int, erro) -> bufio.Writer # WriteRune - bytes.Buffer # WriteRune
• WriteString (string) (int, erro) -> io.stringWriter

Diferenças de bytes.Buffer

• Só pode crescer ou redefinir.

• Possui um mecanismo copyCheck que impede copiá-lo acidentalmente:

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

• Em bytes.Buffer, pode-se acessar os bytes subjacentes como este: (*Buffer).Bytes().

  • strings.Builder evita esse problema.
  • Às vezes, isso não é um problema e é desejado.
  • Por exemplo: Para o comportamento de espreitar quando os bytes são passados ​​para um io.Readeretc.

Confira seu código-fonte para mais detalhes, aqui .

Há uma função de biblioteca no pacote strings chamada Join: http://golang.org/pkg/strings/#Join

Uma olhada no código de Joinmostra uma abordagem semelhante à função Anexar que Kinopiko escreveu: https://golang.org/src/strings/strings.go#L420

Uso:

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

Acabei de comparar a resposta principal postada acima em meu próprio código (uma caminhada recursiva na árvore) e o operador concat simples é realmente mais rápido que o 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()
}

Isso levou 0,81 segundos, enquanto o código a seguir:

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
} 

levou apenas 0,61 segundos. Provavelmente, isso se deve à sobrecarga de criação do novo BufferString.

Atualização: Também testei a joinfunção e ela foi executada em 0,54 segundos.

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,"")
}

Você pode criar uma grande fatia de bytes e copiar os bytes das cadeias curtas usando fatias de cadeia. Existe uma função dada em "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;
}

Então, quando as operações forem concluídas, use string ( )a grande fatia de bytes para convertê-lo em uma sequência novamente.

Esta é a solução mais rápida que não requer que você saiba ou calcule primeiro o tamanho geral do buffer:

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

Pelo meu benchmark , é 20% mais lento que a solução de cópia (8,1ns por anexo em vez de 6,72ns), mas ainda 55% mais rápido que o uso de bytes.Buffer.

package main

import (
  "fmt"
)

func main() {
    var str1 = "string1"
    var str2 = "string2"
    out := fmt.Sprintf("%s %s ",str1, str2)
    fmt.Println(out)
}

Nota adicionada em 2018

No Go 1.10, existe um strings.Buildertipo, consulte esta resposta para obter mais detalhes .

Resposta pré-201x

O código de referência de @ cd1 e outras respostas estão incorretas. b.Nnão deve ser definido na função de benchmark. É definido pela ferramenta go test dinamicamente para determinar se o tempo de execução do teste é estável.

Uma função de benchmark deve executar os mesmos b.Ntempos de teste e o teste dentro do loop deve ser o mesmo para cada iteração. Então, eu o corrigo adicionando um loop interno. Também adiciono benchmarks para outras soluções:

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)
    }
}

O ambiente é OS X 10.11.6, 2.2 GHz Intel Core i7

Resultado dos testes:

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

Conclusão:

1. CopyPreAllocateé o caminho mais rápido; AppendPreAllocateestá bem próximo do número 1, mas é mais fácil escrever o código.
2. Concattem um desempenho realmente ruim, tanto para velocidade quanto para uso de memória. Não use.
3. Buffer#Writee Buffer#WriteStringsão basicamente os mesmos em velocidade, ao contrário do que @ Dani-Br disse no comentário. Considerando que stringestá de fato []byteem Go, faz sentido.
4. bytes.Buffer basicamente usa a mesma solução que Copya manutenção extra de livros e outras coisas.
5. Copye Appenduse um tamanho de inicialização de 64, o mesmo que bytes.
6. Appenduse mais memória e aloque, acho que está relacionado ao algoritmo de crescimento usado. Não está aumentando a memória tão rápido quanto bytes.

Sugestão:

1. Para tarefas simples, como o que o OP deseja, eu usaria Appendou AppendPreAllocate. É rápido o suficiente e fácil de usar.
2. Se for necessário ler e gravar o buffer ao mesmo tempo, use, é bytes.Bufferclaro. É para isso que ele foi projetado.

Minha sugestão original foi

s12 := fmt.Sprint(s1,s2)

Mas acima de resposta usando bytes.Buffer - WriteString () é a maneira mais eficiente.

Minha sugestão inicial usa reflexão e uma opção de tipo. Veja (p *pp) doPrinte(p *pp) printArg
Não há interface universal Stringer () para tipos básicos, como eu pensava ingenuamente.

Pelo menos, Sprint () usa internamente um bytes.Buffer. portanto

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

é aceitável em termos de alocações de memória.

=> A concatenação Sprint () pode ser usada para saída rápida de depuração.
=> Caso contrário, use bytes.Buffer ... WriteString

Expandindo a resposta do cd1: você pode usar append () em vez de copy (). append () faz provisões antecipadas ainda maiores, custando um pouco mais de memória, mas economizando tempo. Eu adicionei mais dois benchmarks no topo do seu. Executar localmente com

go test -bench=. -benchtime=100ms

No meu thinkpad T400s, ele produz:

BenchmarkAppendEmpty    50000000         5.0 ns/op
BenchmarkAppendPrealloc 50000000         3.5 ns/op
BenchmarkCopy           20000000        10.2 ns/op

Esta é a versão real do benchmark fornecida por @ cd1 ( Go 1.8, linux x86_64) com as correções de bugs mencionados por @icza e @PickBoy.

Bytes.Bufferé apenas 7mais rápido que a concatenação direta de cadeias via +operador.

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")
        }
    }
}

Horários:

BenchmarkConcat-4                             300000          6869 ns/op
BenchmarkBuffer-4                            1000000          1186 ns/op

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()
}

Eu faço isso usando o seguinte: -

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))
}

resultado de benchmark com estatísticas de alocação de memória. verifique o código de referência no github .

use strings.Builder para otimizar o desempenho.

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() do pacote "strings"

Se você tem uma incompatibilidade de tipo (como se você estiver tentando ingressar em um int e uma string), você faz RANDOMTYPE (coisa que deseja alterar)

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, ""))
}

Resultado :

hello all you people in here