Эффективное объединение строк в Go: как избежать проблем с производительностью?

Почему оператор += медленный?

В Go строки — это неизменяемые (immutable) последовательности байтов. Каждая операция += создаёт новую строку, копируя содержимое обеих исходных строк в новую область памяти. При конкатенации N строк с помощью += происходит O(N²) операций копирования: первая строка копируется N раз, вторая — N-1 раз и т.д. Для 10 000 строк это приводит к десяткам миллионов копирований байтов.

Основные способы объединения строк в Go

1. Пакет strings.Builder (рекомендуемый способ)

Это современный и самый эффективный способ для большинства случаев. Он использует внутренний буфер, который автоматически расширяется, избегая лишних копирований:

package main

import (
    "fmt"
    "strings"
    "time"
)

func main() {
    data := make([]string, 10000)
    for i := 0; i < 10000; i++ {
        data[i] = fmt.Sprintf("value_%d", i)
    }

    start := time.Now()
    var builder strings.Builder
    // Предварительное выделение памяти (оптимизация)
    builder.Grow(len(data) * 10) // 10 байт на элемент — примерная оценка
    for _, s := range data {
        builder.WriteString(s)
        builder.WriteString(",")
    }
    result := builder.String()
    fmt.Println("Time:", time.Since(start))
    fmt.Println("Length:", len(result))
}

Преимущества:

• Минимальное количество выделений памяти при использовании Grow()
• Метод String() возвращает строку без копирования (использует unsafe.Pointer)
• Потокобезопасность: не гарантируется, но для однопоточного использования идеален

2. Пакет bytes.Buffer

Классический способ, который работал до появления strings.Builder (Go 1.10):

var buf bytes.Buffer
for _, s := range data {
    buf.WriteString(s)
    buf.WriteString(",")
}
result := buf.String()

Отличия от strings.Builder:

• bytes.Buffer возвращает копию строки при вызове String()
• Имеет больше методов (например, WriteByte, WriteRune)
• Немного медленнее из-за дополнительного копирования в String()

3. Оператор += (только для малого количества строк)

Допустим для 2-5 строк, но не более. Пример:

result := "Hello, " + name + "! You are " + age + " years old."

4. Функция strings.Join() (для срезов строк)

Идеально подходит, когда у вас уже есть срез строк и разделитель:

result := strings.Join(data, ",")

Внутри использует strings.Builder с предварительным расчётом размера.

5. Пакет fmt.Sprintf (только для форматирования)

Используйте только когда нужно форматирование, не для массовой конкатенации:

result := fmt.Sprintf("%s,%s", s1, s2)

Сравнение производительности (на 10 000 строк)

Метод              Время      Выделения памяти
-----------------------------------------------
+=                 8.2 ms     50 000 allocs
bytes.Buffer       0.3 ms     2 allocs
strings.Builder    0.2 ms     1 alloc (с Grow)
strings.Join       0.2 ms     1 alloc

Рекомендации

• Для вашего случая (сборка CSV) используйте strings.Join(data, ",") — это самый простой и быстрый способ
• Если нужно добавлять строки в цикле — используйте strings.Builder с предварительным Grow()
• Для форматирования с конкатенацией — fmt.Sprintf или strings.Builder
• Избегайте += в циклах с более чем 5-10 итерациями

package main

import (
    "unsafe"
    "fmt"
)

func concatWithBytes(data []string, sep string) string {
    // Сначала вычисляем общую длину
    totalLen := len(sep) * (len(data) - 1)
    for _, s := range data {
        totalLen += len(s)
    }
    
    // Создаём срез байтов нужного размера
    buf := make([]byte, totalLen)
    pos := 0
    
    for i, s := range data {
        if i > 0 {
            pos += copy(buf[pos:], sep)
        }
        pos += copy(buf[pos:], s)
    }
    
    // Преобразуем []byte в string без копирования
    return *(*string)(unsafe.Pointer(&buf))
}

func main() {
    data := []string{"a", "b", "c", "d"}
    result := concatWithBytes(data, ",")
    fmt.Println(result) // a,b,c,d
}