Что получится, если сложить две строки?

Сложение строк в Go: конкатенация

Если сложить две строки в Go с помощью оператора +, результатом будет их конкатенация (объединение), то есть новая строка, в которой содержимое второй строки присоединяется к концу первой строки.

Пример базовой конкатенации

package main

import "fmt"

func main() {
    str1 := "Hello, "
    str2 := "World!"
    result := str1 + str2
    fmt.Println(result) // Вывод: Hello, World!
}

Ключевые особенности конкатенации строк в Go

1. Строки в Go неизменяемы (immutable). При конкатенации создается совершенно новая строка в памяти, а исходные строки остаются без изменений. Это важно учитывать для производительности при работе с большими объемами текста.

2. Оператор + работает только со строками. Попытка сложить строку с другим типом данных приведет к ошибке компиляции:

str := "Number: " + 42 // Ошибка: invalid operation (mismatched types string and int)

1. Для эффективной конкатенации множества строк рекомендуется использовать strings.Builder:

package main

import (
    "strings"
    "fmt"
)

func main() {
    var builder strings.Builder
    
    builder.WriteString("Hello, ")
    builder.WriteString("World!")
    builder.WriteString(" Welcome ")
    builder.WriteString("to Go!")
    
    result := builder.String()
    fmt.Println(result) // Вывод: Hello, World! Welcome to Go!
}

Альтернативные методы конкатенации

Помимо оператора +, в Go существует несколько других способов объединения строк:

• Функция strings.Join() - особенно эффективна для объединения срезов строк:

package main

import (
    "strings"
    "fmt"
)

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

• Форматирование с помощью fmt.Sprintf():

package main

import "fmt"

func main() {
    str1 := "Hello"
    str2 := "World"
    result := fmt.Sprintf("%s, %s!", str1, str2)
    fmt.Println(result) // Вывод: Hello, World!
}

• Пакет bytes.Buffer (альтернатива strings.Builder для более сложных сценариев):

package main

import (
    "bytes"
    "fmt"
)

func main() {
    var buffer bytes.Buffer
    buffer.WriteString("Hello")
    buffer.WriteString(", ")
    buffer.WriteString("World")
    buffer.WriteByte('!')
    
    result := buffer.String()
    fmt.Println(result) // Вывод: Hello, World!
}

Производительность разных подходов

Для однократной конкатенации двух строк оператор + является наиболее простым и читаемым решением. Однако при множественных конкатенациях в циклах производительность сильно страдает из-за создания промежуточных строк. В таких случаях:

• strings.Builder обеспечивает наилучшую производительность
• strings.Join() оптимален для объединения заранее известного набора строк
• bytes.Buffer полезен при смешанных операциях со строками и байтами

Особенности для русскоязычного текста

Строки в Go представляют собой последовательность байтов в кодировке UTF-8, поэтому конкатенация корректно работает с Unicode-символами:

package main

import "fmt"

func main() {
    rus1 := "Привет, "
    rus2 := "мир!"
    result := rus1 + rus2
    fmt.Println(result) // Вывод: Привет, мир!
    fmt.Println("Длина строки в байтах:", len(result))
    fmt.Println("Длина строки в рунах:", len([]rune(result)))
}

Таким образом, сложение двух строк в Go дает их конкатенацию - простое объединение содержимого, но с важными нюансами производительности и неизменяемости, которые необходимо учитывать при разработке на Go.