Как эффективно объединить строки в Go? - PullRequest
637 голосов
/ 19 ноября 2009

В Go, string является примитивным типом, что означает, что он доступен только для чтения, и каждое его манипулирование создаст новую строку.

Так что, если я хочу многократно объединять строки, не зная длины получаемой строки, каков наилучший способ сделать это?

Наивный путь будет:

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

но это не кажется очень эффективным.

Ответы [ 20 ]

787 голосов
/ 19 ноября 2009

Примечание добавлено в 2018

Начиная с Go 1.10, есть тип strings.Builder, , пожалуйста, посмотрите этот ответ для более подробной информации .

Ответ до 201х

Лучший способ - использовать пакет bytes. Он имеет тип Buffer, который реализует 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())
}

Это происходит за O (n) время.

261 голосов
/ 25 мая 2014

Наиболее эффективный способ объединения строк - использование встроенной функции copy. В моих тестах этот подход примерно в 3 раза быстрее, чем при использовании bytes.Buffer, и намного быстрее (~ 12 000x), чем при использовании оператора +. Кроме того, он использует меньше памяти.

Я создал контрольный пример , чтобы доказать это, и вот результаты:

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

Ниже приведен код для тестирования:

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)
    }
}
135 голосов
/ 13 декабря 2017

Начиная с Go 1.10, здесь strings.Builder, .

Конструктор используется для эффективного построения строки с использованием методов записи. Это минимизирует копирование памяти. Нулевое значение готово к использованию.


Использование:

Это почти то же самое с bytes.Buffer.

package main

import (
    "strings"
    "fmt"
)

func main() {
    var str strings.Builder

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

    fmt.Println(str.String())
}

Поддерживаемые методы и интерфейсы StringBuilder:

Его методы реализуются с учетом существующих интерфейсов, так что вы можете легко переключаться на новый Builder в своем коде.


Использование нулевого значения:

var buf strings.Builder

Отличия от байтов. Буфер:

  • Может только расти или сбрасываться.

  • В bytes.Buffer можно получить доступ к нижележащим байтам следующим образом: (*Buffer).Bytes(); strings.Builder предотвращает эту проблему. Иногда это не является проблемой, хотя и желательно вместо этого (например, для просмотра поведения при передаче байтов в io.Reader и т. Д.).

  • Он также имеет встроенный механизм copyCheck, который предотвращает случайное копирование (func (b *Builder) copyCheck() { ... }).


Проверьте его исходный код здесь .

126 голосов
/ 19 ноября 2009

В пакете строк есть библиотечная функция с именем Join: http://golang.org/pkg/strings/#Join

Взгляд на код Join показывает аналогичный подход к функции добавления. Кинопико пишет: https://golang.org/src/strings/strings.go#L420

Использование:

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
40 голосов
/ 29 апреля 2012

Я только что проверил верхний ответ, опубликованный выше, в своем собственном коде (рекурсивный обход дерева), и простой оператор concat на самом деле быстрее, чем 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()
}

Это заняло 0,81 секунды, тогда как следующий код:

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
} 

заняло всего 0,61 секунды. Вероятно, это связано с накладными расходами на создание нового BufferString.

Обновление: Я также протестировал функцию join, и она запустилась за 0,54 секунды.

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,"")
}
22 голосов
/ 19 ноября 2009

Вы можете создать большой кусочек байтов и скопировать байты коротких строк в него, используя кусочки строк. В «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;
}

Затем, когда операции завершатся, используйте string ( ) на большом кусочке байтов, чтобы снова преобразовать его в строку.

21 голосов
/ 28 августа 2014

Это самое быстрое решение, которое не требует Вам сначала нужно узнать или рассчитать общий размер буфера:

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

По моим тестам , это на 20% медленнее, чем решение для копирования (8,1 нс на добавляется вместо 6,72 нс), но все еще на 55% быстрее, чем при использовании байтов. Буфер.

21 голосов
/ 28 апреля 2017

Примечание добавлено в 2018

Начиная с Go 1.10, есть тип strings.Builder, , пожалуйста, посмотрите этот ответ для более подробной информации .

Ответ до 201х

Код теста @ cd1 и другие ответы неверны. b.N не должен быть установлен в тестовой функции. Он устанавливается инструментом динамического тестирования для определения того, стабильно ли время выполнения теста.

Функция бенчмарка должна запускать один и тот же тест b.N раз, и тест внутри цикла должен быть одинаковым для каждой итерации. Поэтому я исправляю это, добавляя внутренний цикл. Я также добавлю тесты для некоторых других решений:

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

Среда - OS X 10.11.6, 2,2 ГГц Intel Core i7

Результаты испытаний:

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

Вывод:

  1. CopyPreAllocate - самый быстрый способ; AppendPreAllocate довольно близко к №1, но код проще написать.
  2. Concat имеет очень плохую производительность как по скорости, так и по использованию памяти. Не используйте его.
  3. Buffer#Write и Buffer#WriteString в основном одинаковы по скорости, в отличие от того, что @ Dani-Br сказал в комментарии. Учитывая, что string действительно []byte в Go, это имеет смысл.
  4. байт. В основном, буфер использует то же решение, что и Copy, с дополнительным ведением бухгалтерского учета и другими вещами.
  5. Copy и Append используют размер начальной загрузки 64, такой же, как байты. Буфер
  6. Append использует больше памяти и выделяет, я думаю, это связано с алгоритмом роста, который он использует. Память растет не так быстро, как байты. Буфер

Предложение:

  1. Для простых задач, таких как то, что хочет OP, я бы использовал Append или AppendPreAllocate. Он достаточно быстрый и простой в использовании.
  2. Если необходимо одновременно прочитать и записать буфер, используйте, конечно, bytes.Buffer. Вот для чего он предназначен.
18 голосов
/ 06 марта 2016
package main

import (
  "fmt"
)

func main() {
    var str1 = "string1"
    var str2 = "string2"
    out := fmt.Sprintf("%s %s ",str1, str2)
    fmt.Println(out)
}
12 голосов
/ 02 июля 2013

Мое оригинальное предложение было

s12 := fmt.Sprint(s1,s2)

Но ответ выше, используя bytes.Buffer - WriteString() is the most efficient way.

My initial suggestion uses reflection and a type switch. См. (p *pp) doPrint и (p *pp) printArg
Как я наивно думал, универсального интерфейса Stringer () для базовых типов не существует.

По крайней мере, Sprint () внутренне использует байты. Буфер. Таким образом

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

является приемлемым с точки зрения выделения памяти.

=> Сцепление Sprint () может использоваться для быстрого вывода отладочной информации.
=> В противном случае использовать bytes.Buffer ... WriteString

...