Эффективная конкатенация строк в Go: как правильно и быстро соединять строки

Правильный ответ: используйте strings.Builder

В современных версиях Go (1.10+) лучший способ конкатенации строк в цикле — это strings.Builder. Он специально спроектирован для эффективного построения строк и минимизирует количество аллокаций памяти.

Вот как переписать ваш пример:

package main

import (
    "fmt"
    "strings"
)

func main() {
    var sb strings.Builder
    // Предварительное выделение памяти ускоряет работу
    sb.Grow(1000000) // зарезервируем ~1 МБ

    for i := 0; i < 100000; i++ {
        sb.WriteString(fmt.Sprintf("<div>%d</div>", i))
    }

    result := sb.String()
    fmt.Println(len(result))
}

Почему это работает быстрее?

• Внутренний буфер: strings.Builder хранит данные в изменяемом срезе байтов ([]byte), который растёт по мере необходимости (обычно удваивая ёмкость).
• Минимум копирований: В отличие от оператора +, который каждый раз копирует всю старую строку, Builder просто дописывает новые данные в конец буфера.
• Метод Grow(): Если вы знаете примерный размер итоговой строки, вызовите sb.Grow(n) — это выделит память один раз, а не несколько раз при расширении буфера.
• Финальный String(): При вызове .String() создаётся новая строка, но это единственное копирование данных за всё время работы.

Сравнение с другими подходами

Бенчмарк для наглядности

func BenchmarkPlus(b *testing.B) {
    var s string
    for i := 0; i < b.N; i++ {
        s += "a"
    }
    _ = s
}

func BenchmarkBuilder(b *testing.B) {
    var sb strings.Builder
    for i := 0; i < b.N; i++ {
        sb.WriteString("a")
    }
    _ = sb.String()
}

При b.N = 100000 оператор + будет в 1000+ раз медленнее и создаст в сотни раз больше мусора для GC.

Важные нюансы

• Не копируйте Builder: strings.Builder не должен копироваться после начала записи (используйте указатель *strings.Builder).
• Для форматирования: Если вам нужно вставлять числа/переменные, используйте fmt.Fprintf(&sb, "...", args) вместо sb.WriteString(fmt.Sprintf(...)) — это избежит лишней аллокации промежуточной строки.
• Альтернатива для IO: Если вы пишете в сеть или файл, рассмотрите bufio.Writer поверх strings.Builder.

Итог: всегда используйте strings.Builder для конкатенации строк в циклах — это идиоматичный, быстрый и экономичный способ в Go.

var buf bytes.Buffer
for i := 0; i < 100000; i++ {
    fmt.Fprintf(&buf, "<div>%d</div>", i)
}
result := buf.String()

data := make([]byte, 0, 1000000)
for i := 0; i < 100000; i++ {
    data = append(data, fmt.Sprintf("<div>%d</div>", i)...)
}
result := string(data)