Cómo concatenar cadenas de manera eficiente en go

En Go, a stringes un tipo primitivo, lo que significa que es de solo lectura, y cada manipulación creará una nueva cadena.

Entonces, si quiero concatenar cadenas muchas veces sin saber la longitud de la cadena resultante, ¿cuál es la mejor manera de hacerlo?

La forma ingenua sería:

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

pero eso no parece muy eficiente.

Nueva manera:

De Go 1.10 hay un strings.Buildertipo, eche un vistazo a esta respuesta para obtener más detalles .

Vieja forma:

Usa el bytespaquete. Tiene un 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())
}

Esto lo hace en O (n) tiempo.

La forma más eficiente de concatenar cadenas es usar la función incorporada copy. En mis pruebas, ese enfoque es ~ 3 veces más rápido que usarlo bytes.Buffery mucho más rápido (~ 12,000x) que usar el operador +. Además, usa menos memoria.

He creado un caso de prueba para probar esto y aquí están los 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

A continuación se muestra el código para la prueba:

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

En Go 1.10+ hay strings.Builder, aquí .

Un generador se usa para construir eficientemente una cadena usando métodos de escritura. Minimiza la copia de memoria. El valor cero está listo para usar.

Ejemplo

Es casi lo mismo 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())
}

Haga clic para ver esto en el patio de recreo .

Nota

• No copie un valor de StringBuilder ya que almacena en caché los datos subyacentes.
• Si desea compartir un valor de StringBuilder, use un puntero a él.

Interfaces soportadas

Los métodos de StringBuilder se implementan teniendo en cuenta las interfaces existentes. Para que pueda cambiar al nuevo tipo de generador fácilmente en su código.

• Grow (int) -> bytes.Buffer # Grow
• Len () int -> bytes.Buffer # Len
• Reset () -> bytes Búfer # Reset
• Cadena () cadena -> fmt.Stringer
• Escribir ([] byte) (int, error) -> io.Writer
• Error de WriteByte (byte) -> io.ByteWriter
• WriteRune (runa) (int, error) -> bufio.Writer # WriteRune - bytes.Buffer # WriteRune
• WriteString (cadena) (int, error) -> io.stringWriter

Diferencias de bytes.

• Solo puede crecer o restablecerse.

• Tiene un mecanismo copyCheck incorporado que evita copiarlo de manera accidental:

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

• En bytes.Buffer, se puede acceder a los bytes subyacentes como este: (*Buffer).Bytes().

  • strings.Builder Previene este problema.
  • A veces, esto no es un problema y se desea en su lugar.
  • Por ejemplo: para el comportamiento de espiar cuando los bytes se pasan a un io.Readeretc.

Mira su código fuente para más detalles, aquí .

Hay una función de biblioteca en el paquete de cadenas llamada Join: http://golang.org/pkg/strings/#Join

Una mirada al código de Joinmuestra un enfoque similar a la función Append que Kinopiko escribió: 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

Acabo de comparar la respuesta superior publicada anteriormente en mi propio código (un recorrido recursivo en árbol) y el operador concat simple es en realidad más rápido que el 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()
}

Esto tardó 0,81 segundos, mientras que el siguiente código:

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
} 

solo tomó 0.61 segundos. Esto probablemente se deba a la sobrecarga de crear el nuevo BufferString.

Actualización: también comparé la joinfunción y funcionó en 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,"")
}

Podrías crear una gran porción de bytes y copiar los bytes de las cadenas cortas usando rebanadas de cadena. Hay una función dada en "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;
}

Luego, cuando finalicen las operaciones, utilícelas string ( )en la gran porción de bytes para convertirla nuevamente en una cadena.

Esta es la solución más rápida que no requiere que usted sepa o calcule primero el tamaño total del búfer:

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

Según mi punto de referencia , es un 20% más lento que la solución de copia (8.1ns por apéndice en lugar de 6.72ns) pero aún 55% más rápido que usar bytes.

package main

import (
  "fmt"
)

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

Nota agregada en 2018

De Go 1.10 hay un strings.Buildertipo, eche un vistazo a esta respuesta para obtener más detalles .

Respuesta previa a 201x

El código de referencia de @ cd1 y otras respuestas son incorrectas. b.Nno se supone que se establezca en la función de referencia. La herramienta go test la establece dinámicamente para determinar si el tiempo de ejecución de la prueba es estable.

Una función de referencia debe ejecutar los mismos b.Ntiempos de prueba y la prueba dentro del ciclo debe ser la misma para cada iteración. Así que lo arreglo agregando un bucle interno. También agrego puntos de referencia para algunas otras soluciones:

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

El entorno es OS X 10.11.6, 2.2 GHz Intel Core i7

Resultados de la prueba:

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

Conclusión:

1. CopyPreAllocatees la forma más rápida AppendPreAllocateestá bastante cerca del número 1, pero es más fácil escribir el código.
2. Concattiene un rendimiento realmente malo tanto en velocidad como en uso de memoria. No lo uses
3. Buffer#Writey Buffer#WriteStringson básicamente iguales en velocidad, al contrario de lo que dijo @ Dani-Br en el comentario. Teniendo en cuenta que sí stringestá []byteen Go, tiene sentido.
4. bytes.Buffer básicamente usa la misma solución que Copycon la contabilidad adicional y otras cosas.
5. Copyy Appenduse un tamaño de bootstrap de 64, igual que los bytes.
6. Appendusa más memoria y asignaciones, creo que está relacionado con el algoritmo de crecimiento que usa. No está creciendo la memoria tan rápido como los bytes.

Sugerencia:

1. Para tareas simples como lo que OP quiere, usaría Appendo AppendPreAllocate. Es lo suficientemente rápido y fácil de usar.
2. Si necesita leer y escribir el búfer al mismo tiempo, utilice, bytes.Bufferpor supuesto. Para eso está diseñado.

Mi sugerencia original fue

s12 := fmt.Sprint(s1,s2)

Pero la respuesta anterior usa bytes.Buffer - WriteString () es la forma más eficiente.

Mi sugerencia inicial usa reflexión y un interruptor de tipo. Ver (p *pp) doPrinty(p *pp) printArg
no hay una interfaz universal Stringer () para tipos básicos, como ingenuamente pensé.

Al menos, sin embargo, Sprint () usa internamente un bytes. Así

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

es aceptable en términos de asignaciones de memoria.

=> La concatenación Sprint () se puede utilizar para la salida de depuración rápida.
=> De lo contrario, use bytes.Buffer ... WriteString

Ampliando la respuesta de cd1: puede usar append () en lugar de copy (). append () hace provisiones anticipadas cada vez más grandes, cuesta un poco más de memoria, pero ahorra tiempo. Agregué dos puntos de referencia más en la parte superior de los suyos. Ejecutar localmente con

go test -bench=. -benchtime=100ms

En mi thinkpad T400s produce:

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

Esta es la versión real de benchmark proporcionada por @ cd1 ( Go 1.8, linux x86_64) con las correcciones de errores mencionados por @icza y @PickBoy.

Bytes.Bufferes solo 7veces más rápido que la concatenación directa de cadenas a través del +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")
        }
    }
}

Tiempos:

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 hago usando lo siguiente: -

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 referencia con estadísticas de asignación de memoria. verifique el código de referencia en github .

use strings.Builder para optimizar el rendimiento.

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() del paquete "cadenas"

Si tiene una falta de coincidencia de tipos (como si intenta unir un int y una cadena), hace RANDOMTYPE (lo que desea cambiar)

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

Salida:

hello all you people in here