Как объединить срез строк в одну строку в Go?

Question

learn_code32 · 09.05.2026

Как объединить срез строк в одну строку в Go?

Всем привет! Я только начал изучать Go и столкнулся с проблемой при работе со строками. У меня есть срез (slice) строк, например:

words := []string{"Hello", "world", "from", "Go"}

Мне нужно объединить все эти строки в одну, разделяя их пробелом, чтобы получить результат: `"Hello world from Go"`. В других языках (например, в Python) я бы просто использовал `" ".join(words)`, но в Go такого метода нет. Я пробовал написать цикл вручную, но получается громоздко, и я не уверен, что это эффективно:

result := ""
for i, word := range words {
    if i > 0 {
        result += " "
    }
    result += word
}

Это работает, но я слышал, что конкатенация строк через `+=` в цикле может быть медленной из-за постоянного выделения памяти. Есть ли в Go встроенный способ сделать это красиво и быстро? Может быть, есть функция из стандартной библиотеки? Буду благодарен за примеры кода и объяснение. <<>>

Используйте strings.Join — стандартное и эффективное решение

В Go для объединения среза строк в одну строку с разделителем существует встроенная функция strings.Join из пакета strings. Это наиболее правильный и производительный способ, рекомендованный разработчиками языка. Ваш пример с циклом действительно неоптимален: каждая операция += создаёт новую строку, копируя старую, что приводит к квадратичной сложности по памяти и времени.

Вот как выглядит решение с strings.Join:

package main

import (
    "fmt"
    "strings"
)

func main() {
    words := []string{"Hello", "world", "from", "Go"}
    result := strings.Join(words, " ")
    fmt.Println(result) // Вывод: Hello world from Go
}

Как это работает

Функция strings.Join принимает два аргумента:

срез строк (первый аргумент) — то, что нужно объединить;
разделитель (второй аргумент) — строка, которая будет вставлена между элементами.

Она возвращает одну строку. Если срез пуст, возвращается пустая строка. Если в срезе один элемент, разделитель не используется.

Производительность

strings.Join работает эффективно, потому что:

Сначала вычисляется общая длина результирующей строки (сумма длин всех элементов + длина разделителя × (количество элементов − 1)).
Затем выделяется память ровно один раз под эту длину.
После этого все строки копируются в выделенный буфер.

Это даёт сложность O(n) по времени и минимизирует нагрузку на сборщик мусора. Ваш ручной цикл с += имел бы сложность O(n²) из-за многократных перевыделений памяти.

Другие примеры использования

// Объединение с запятой
csv := strings.Join([]string{"a", "b", "c"}, ",")
fmt.Println(csv) // a,b,c

// Без разделителя
joined := strings.Join([]string{"one", "two", "three"}, "")
fmt.Println(joined) // onetwothree

// Срез с одним элементом
single := strings.Join([]string{"only"}, "---")
fmt.Println(single) // only

// Пустой срез
empty := strings.Join([]string{}, ", ")
fmt.Println(empty) // (пустая строка)

Когда ручной цикл всё же нужен

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

var builder strings.Builder
for i, word := range words {
    if i > 0 {
        builder.WriteString(" ")
    }
    builder.WriteString(word)
}
result := builder.String()

Но для простого объединения с разделителем strings.Join — это идиоматичный выбор.

<<>>

Альтернатива: пакет bytes.Buffer

До появления strings.Builder (Go 1.10) часто использовали bytes.Buffer. Он тоже эффективен, но менее удобен, так как работает с байтами, а не с рунами. Пример:

import (
    "bytes"
    "fmt"
)

func main() {
    words := []string{"Hello", "world", "from", "Go"}
    var buffer bytes.Buffer
    for i, word := range words {
        if i > 0 {
            buffer.WriteString(" ")
        }
        buffer.WriteString(word)
    }
    result := buffer.String()
    fmt.Println(result) // Hello world from Go
}

bytes.Buffer автоматически расширяет свой внутренний буфер по мере необходимости, но делает это реже, чем конкатенация через +=. Однако он менее производителен, чем strings.Join, из-за накладных расходов на проверки границ и вызовы методов.

Когда использовать: если вам нужно не только объединить строки, но и добавить в результат другие типы данных (например, числа через fmt.Fprintf), bytes.Buffer может быть удобнее. Но для простого объединения строк с разделителем strings.Join остаётся лучшим выбором.

0 ответов