Comment concaténer efficacement des chaînes dans go

Dans Go, a stringest un type primitif, ce qui signifie qu'il est en lecture seule, et chaque manipulation de celui-ci créera une nouvelle chaîne.

Donc, si je veux concaténer des chaînes plusieurs fois sans connaître la longueur de la chaîne résultante, quelle est la meilleure façon de le faire?

La voie naïve serait:

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

mais cela ne semble pas très efficace.

Nouvelle façon:

À partir de Go 1.10, il existe un strings.Buildertype, veuillez jeter un œil à cette réponse pour plus de détails .

Old Way:

Utilisez le bytespackage. Il a un Buffertype qui implémente 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())
}

Cela le fait en temps O (n).

La façon la plus efficace de concaténer des chaînes est d'utiliser la fonction intégrée copy. Dans mes tests, cette approche est ~ 3x plus rapide que l'utilisation bytes.Bufferet beaucoup plus rapide (~ 12 000x) que l'utilisation de l'opérateur +. En outre, il utilise moins de mémoire.

J'ai créé un cas de test pour le prouver et voici les résultats:

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

Voici le code pour les tests:

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

Dans Go 1.10+, il y strings.Builderen a ici .

Un générateur est utilisé pour créer efficacement une chaîne à l'aide de méthodes d'écriture. Il minimise la copie de la mémoire. La valeur zéro est prête à l'emploi.

Exemple

C'est presque la même chose avec 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())
}

Cliquez pour voir ceci sur le terrain de jeu .

Remarque

• Ne copiez pas une valeur StringBuilder car elle met en cache les données sous-jacentes.
• Si vous souhaitez partager une valeur StringBuilder, utilisez un pointeur vers celle-ci.

Interfaces prises en charge

Les méthodes de StringBuilder sont mises en œuvre avec les interfaces existantes à l'esprit. Pour que vous puissiez basculer facilement vers le nouveau type Builder dans votre code.

• Grow (int) -> bytes.Buffer # Grow
• Len () int -> octets.Buffer # Len
• Reset () -> bytes.Buffer # Reset
• String () string -> fmt.Stringer
• Écriture ([] octet) (int, erreur) -> io.Writer
• Erreur WriteByte (byte) -> io.ByteWriter
• WriteRune (rune) (int, erreur) -> bufio.Writer # WriteRune - bytes.Buffer # WriteRune
• WriteString (chaîne) (int, erreur) -> io.stringWriter

Différences par rapport aux octets.Buffer

• Il ne peut que croître ou se réinitialiser.

• Il a un mécanisme copyCheck intégré qui empêche de le copier accidentellement:

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

• Dans bytes.Buffer, on peut accéder aux octets sous - jacents comme ceci: (*Buffer).Bytes().

  • strings.Builder empêche ce problème.
  • Parfois, ce n'est pas un problème et souhaité à la place.
  • Par exemple: pour le comportement furtif lorsque les octets sont passés à un io.Readeretc.

Consultez son code source pour plus de détails, ici .

Il y a une fonction de bibliothèque dans le package de chaînes appelée Join: http://golang.org/pkg/strings/#Join

Un regard sur le code de Joinmontre une approche similaire à la fonction Append Kinopiko a écrit: https://golang.org/src/strings/strings.go#L420

Usage:

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

Je viens de comparer la première réponse publiée ci-dessus dans mon propre code (une promenade récursive dans l'arbre) et l'opérateur de concaténation simple est en fait plus rapide que le 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()
}

Cela a pris 0,81 seconde, alors que le code suivant:

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
} 

n'a pris que 0,61 secondes. Cela est probablement dû aux frais généraux liés à la création du nouveau BufferString.

Mise à jour: j'ai également testé la joinfonction et elle a fonctionné en 0,54 seconde.

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

Vous pouvez créer une grande tranche d'octets et y copier les octets des chaînes courtes à l'aide de tranches de chaîne. Il y a une fonction donnée dans "Go efficace":

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

Ensuite, lorsque les opérations sont terminées, utilisez string ( )sur la grande tranche d'octets pour la convertir à nouveau en chaîne.

Il s'agit de la solution la plus rapide qui ne nécessite pas que vous connaissiez ou calculiez d'abord la taille globale du tampon:

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

D'après mes tests , c'est 20% plus lent que la solution de copie (8,1 ns par ajout plutôt que 6,72 ns) mais toujours 55% plus rapide que l'utilisation 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)
}

Note ajoutée en 2018

À partir de Go 1.10, il existe un strings.Buildertype, veuillez jeter un œil à cette réponse pour plus de détails .

Réponse pré-201x

Le code de référence de @ cd1 et d'autres réponses sont erronés. b.Nn'est pas censé être défini dans la fonction de référence. Il est défini dynamiquement par l'outil de test go pour déterminer si le temps d'exécution du test est stable.

Une fonction de référence doit exécuter les mêmes b.Ntemps de test et le test à l'intérieur de la boucle doit être le même pour chaque itération. Je le corrige donc en ajoutant une boucle intérieure. J'ajoute également des repères pour d'autres solutions:

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'environnement est OS X 10.11.6, 2,2 GHz Intel Core i7

Résultats de 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

Conclusion:

1. CopyPreAllocateest le moyen le plus rapide; AppendPreAllocateest assez proche de No.1, mais il est plus facile d'écrire le code.
2. Concata de très mauvaises performances à la fois pour la vitesse et l'utilisation de la mémoire. Ne l'utilisez pas.
3. Buffer#Writeet Buffer#WriteStringsont fondamentalement les mêmes en vitesse, contrairement à ce que @ Dani-Br a dit dans le commentaire. Considérant que stringc'est bien []bytedans Go, ça a du sens.
4. bytes.Buffer utilise essentiellement la même solution Copyqu'avec la tenue de livres supplémentaires et d'autres choses.
5. Copyet Appendutilisez une taille de bootstrap de 64, la même que celle des octets.
6. Appendutiliser plus de mémoire et d'allocations, je pense que c'est lié à l'algorithme de croissance qu'il utilise. Cela n'augmente pas la mémoire aussi vite que les octets.

Suggestion:

1. Pour une tâche simple telle que ce que veut OP, j'utiliserais Appendou AppendPreAllocate. C'est assez rapide et facile à utiliser.
2. Si vous avez besoin de lire et d'écrire le tampon en même temps, utilisez bytes.Bufferbien sûr. C'est pour ça qu'il est conçu.

Ma suggestion initiale était

s12 := fmt.Sprint(s1,s2)

Mais la réponse ci-dessus utilise bytes.Buffer - WriteString () est le moyen le plus efficace.

Ma suggestion initiale utilise la réflexion et un commutateur de type. Voir (p *pp) doPrintet(p *pp) printArg
Il n'y a pas d'interface universelle Stringer () pour les types de base, comme je l'avais naïvement pensé.

Au moins cependant, Sprint () utilise en interne un octet.Buffer. Donc

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

est acceptable en termes d'allocations de mémoire.

=> La concaténation Sprint () peut être utilisée pour une sortie de débogage rapide.
=> Sinon, utilisez bytes.Buffer ... WriteString

Extension de la réponse de cd1: vous pouvez utiliser append () au lieu de copy (). append () fait des provisions d'avance toujours plus grandes, coûtant un peu plus de mémoire, mais économisant du temps. J'ai ajouté deux autres repères en haut de la vôtre. Exécuter localement avec

go test -bench=. -benchtime=100ms

Sur mon thinkpad T400s ça donne:

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

Il s'agit de la version actuelle de benchmark fournie par @ cd1 ( Go 1.8, linux x86_64) avec les correctifs de bugs mentionnés par @icza et @PickBoy.

Bytes.Bufferest seulement 7plus rapide que la concaténation directe de chaînes via l' +opérateur.

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

Calendrier:

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

goutils.

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

Je le fais en utilisant ce qui suit: -

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

résultat de référence avec statistiques d'allocation de mémoire. vérifier le code de référence sur github .

utilisez strings.Builder pour optimiser les performances.

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() du package "strings"

Si vous avez une incompatibilité de type (comme si vous essayez de joindre un int et une chaîne), vous faites RANDOMTYPE (chose que vous voulez changer)

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

Production :

hello all you people in here