Come concatenare in modo efficiente le stringhe in corso

In Go, a stringè un tipo primitivo, il che significa che è di sola lettura e ogni sua manipolazione creerà una nuova stringa.

Quindi, se voglio concatenare le stringhe molte volte senza conoscere la lunghezza della stringa risultante, qual è il modo migliore per farlo?

Il modo ingenuo sarebbe:

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

ma questo non sembra molto efficiente.

Nuovo modo:

Da Go 1.10 c'è un strings.Buildertipo, per favore dai un'occhiata a questa risposta per maggiori dettagli .

Vecchio modo:

Usa il bytespacchetto. Ha un Buffertipo che 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())
}

Questo lo fa in O (n) tempo.

Il modo più efficiente per concatenare le stringhe è utilizzare la funzione integrata copy. Nei miei test, questo approccio è ~ 3 volte più veloce dell'uso bytes.Buffere molto più veloce (~ 12.000 volte) rispetto all'utilizzo dell'operatore +. Inoltre, utilizza meno memoria.

Ho creato un caso di prova per dimostrarlo e qui ci sono i risultati:

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

Di seguito è riportato il codice per il test:

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

In Go 1.10+ c'è strings.Builder, qui .

Un builder viene utilizzato per creare in modo efficiente una stringa utilizzando i metodi di scrittura. Riduce al minimo la copia della memoria. Il valore zero è pronto per l'uso.

Esempio

È quasi lo stesso con 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())
}

Clicca per vedere questo nel parco giochi .

Nota

• Non copiare un valore StringBuilder poiché memorizza nella cache i dati sottostanti.
• Se si desidera condividere un valore StringBuilder, utilizzare un puntatore ad esso.

Interfacce supportate

I metodi di StringBuilder vengono implementati tenendo conto delle interfacce esistenti. In questo modo puoi passare facilmente al nuovo tipo di Builder nel tuo codice.

• Grow (int) -> bytes.Buffer # Grow
• Len () int -> bytes.Buffer # Len
• Reset () -> bytes.Buffer # Reset
• String () string -> fmt.Stringer
• Scrivi ([] byte) (int, errore) -> io.Writer
• Errore WriteByte (byte) -> io.ByteWriter
• WriteRune (rune) (int, error) -> bufio.Writer # WriteRune - bytes.Buffer # WriteRune
• WriteString (stringa) (int, errore) -> io.stringWriter

Differenze dai byte. Buffer

• Può solo crescere o ripristinare.

• Ha un meccanismo incorporato di CopyCheck che impedisce la copia accidentale:

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

• In bytes.Buffer, si può accedere ai bytes sottostanti come questo: (*Buffer).Bytes().

  • strings.Builder previene questo problema.
  • A volte, questo non è un problema e invece lo si desidera.
  • Ad esempio: per il comportamento di sbirciatura quando i byte vengono passati a un io.Readerecc.

Controlla il suo codice sorgente per maggiori dettagli, qui .

Esiste una funzione di libreria nel pacchetto stringhe chiamata Join: http://golang.org/pkg/strings/#Join

Uno sguardo al codice di Joinmostra un approccio simile alla funzione Append Kinopiko ha scritto: 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

Ho appena confrontato la risposta più sopra pubblicata nel mio codice (una passeggiata ad albero ricorsiva) e il semplice operatore concat è in realtà più veloce di 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()
}

Questa operazione ha richiesto 0,81 secondi, mentre il seguente codice:

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
} 

ci sono voluti solo 0,61 secondi. Ciò è probabilmente dovuto al sovraccarico di creare il nuovo BufferString.

Aggiornamento: ho anche confrontato la joinfunzione e ha funzionato in 0,54 secondi.

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

È possibile creare una grande porzione di byte e copiarvi i byte delle stringhe brevi usando le sezioni di stringa. C'è una funzione fornita in "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;
}

Quindi, al termine delle operazioni, utilizzare string ( )la porzione grande di byte per convertirla nuovamente in una stringa.

Questa è la soluzione più veloce che non richiede di conoscere o calcolare prima la dimensione complessiva del buffer:

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

Secondo il mio benchmark , è più lento del 20% rispetto alla soluzione di copia (8,1 ns per append anziché 6,72 ns) ma ancora più veloce del 55% rispetto all'utilizzo dei byte.

package main

import (
  "fmt"
)

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

Nota aggiunta nel 2018

Da Go 1.10 c'è un strings.Buildertipo, per favore dai un'occhiata a questa risposta per maggiori dettagli .

Risposta pre-201x

Il codice di riferimento di @ cd1 e altre risposte sono errati. b.Nnon dovrebbe essere impostato nella funzione benchmark. Viene impostato in modo dinamico dallo strumento go test per determinare se il tempo di esecuzione del test è stabile.

Una funzione di benchmark dovrebbe eseguire gli stessi b.Ntempi di test e il test all'interno del loop dovrebbe essere lo stesso per ogni iterazione. Quindi lo aggiusto aggiungendo un loop interno. Aggiungo anche benchmark per alcune altre soluzioni:

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

L'ambiente è OS X 10.11.6, Intel Core i7 a 2,2 GHz

Risultati del test:

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

Conclusione:

1. CopyPreAllocateè il modo più veloce; AppendPreAllocateè abbastanza vicino a No.1, ma è più facile scrivere il codice.
2. Concatha prestazioni pessime sia per la velocità che per l'utilizzo della memoria. Non usarlo.
3. Buffer#Writee Buffer#WriteStringsono sostanzialmente gli stessi in termini di velocità, contrariamente a quanto ha detto @ Dani-Br nel commento. Considerare che stringè davvero []bytein Go, ha senso.
4. bytes.Buffer utilizza fondamentalmente la stessa soluzione Copycon la tenuta di libri extra e altre cose.
5. Copye Appendusa una dimensione bootstrap di 64, uguale a byte.Buffer
6. Appendusa più memoria e alloc, penso che sia correlato all'algoritmo di crescita che usa. Non sta crescendo la memoria velocemente quanto i byte. Buffer

Suggerimento:

1. Per un compito semplice come quello che vuole OP, vorrei usare Appendo AppendPreAllocate. È abbastanza veloce e facile da usare.
2. Se è necessario leggere e scrivere il buffer contemporaneamente, utilizzare bytes.Bufferovviamente. È per questo che è progettato.

Il mio suggerimento originale era

s12 := fmt.Sprint(s1,s2)

Ma sopra la risposta usando bytes.Buffer - WriteString () è il modo più efficiente.

Il mio suggerimento iniziale utilizza la riflessione e un interruttore di tipo. Vedere (p *pp) doPrinte(p *pp) printArg
non esiste un'interfaccia universale Stringer () per i tipi di base, come avevo ingenuamente pensato.

Almeno, Sprint () utilizza internamente un byte. Buffer. così

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

è accettabile in termini di allocazioni di memoria.

=> La concatenazione Sprint () può essere utilizzata per un output di debug rapido.
=> Altrimenti usa bytes.Buffer ... WriteString

Espandendo la risposta di cd1: potresti usare append () invece di copy (). append () rende disposizioni anticipate sempre più grandi, costando un po 'più di memoria, ma risparmiando tempo. Ho aggiunto altri due benchmark nella parte superiore del tuo. Esegui localmente con

go test -bench=. -benchtime=100ms

Sul mio thinkpad T400s si ottiene:

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

Questa è la versione attuale del benchmark fornita da @ cd1 ( Go 1.8, linux x86_64) con le correzioni di bug menzionate da @icza e @PickBoy.

Bytes.Bufferè solo 7volte più veloce della concatenazione di stringhe diretta tramite +operatore.

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

Tempi:

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

Lo faccio usando il seguente: -

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

risultato del benchmark con statistiche di allocazione della memoria. controlla il codice di riferimento su github .

usa stringhe.Builder per ottimizzare le prestazioni.

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() dal pacchetto "stringhe"

Se hai un tipo non corrispondente (come se stai provando a unire un int e una stringa), fai RANDOMTYPE (cosa che vuoi cambiare)

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

Produzione :

hello all you people in here