Какая специфика работы со строками?

Специфика работы со строками в Go

Работа со строками в Go имеет ряд важных особенностей, которые отличают язык от других популярных языков программирования. Понимание этих нюансов критически важно для написания эффективного и корректного кода.

Строки — это иммутабельные последовательности байт

В Go строка (string) — это иммутабельная (неизменяемая) последовательность байт, а не массив символов. Это фундаментальное отличие имеет несколько последствий:

s := "Hello, World!"
// s[0] = 'h' // Ошибка компиляции: строки неизменяемы

// Создание новой строки через конкатенацию
s2 := "Hello, " + "World!"

Иммутабельность обеспечивает потокобезопасность и позволяет компилятору оптимизировать использование памяти (например, через механизм подстрок без копирования).

Кодировка UTF-8 по умолчанию

Go использует UTF-8 как нативную кодировку для строк, что делает язык особенно удобным для работы с Unicode:

s := "Привет, 世界!" // Строка содержит символы кириллицы и иероглифы
fmt.Println(len(s)) // Выведет 19 (количество байт, а не символов!)

Важно понимать разницу между байтами и рунами (символами Unicode):

s := "Hello"
fmt.Println(len(s)) // 5 байт

s2 := "Привет"
fmt.Println(len(s2)) // 12 байт (каждый кириллический символ — 2 байта)

// Для подсчета символов используйте пакет unicode/utf8
fmt.Println(utf8.RuneCountInString(s2)) // 6 символов

Итерация по строкам

При итерации по строке с помощью цикла for...range происходит автоматическая декодирование UTF-8:

s := "Hello, 世界!"
for i, r := range s {
    fmt.Printf("Позиция %d: символ %c (кодовая точка U+%04X)\n", i, r, r)
}
// Вывод покажет правильные символы, включая иероглифы

Однако при обращении по индексу вы получаете байт, а не символ:

s := "Привет"
fmt.Printf("%v\n", s[0]) // 208 — первый байт символа 'П', а не сам символ

Преобразование в слайс байт и рун

Для модификации строк или эффективной обработки необходимо преобразование:

// Преобразование строки в слайс байт
str := "Hello"
bytes := []byte(str) // Копирование данных
bytes[0] = 'h'
str2 := string(bytes) // Снова копирование
fmt.Println(str2) // "hello"

// Преобразование строки в слайс рун
runes := []rune("Привет, мир!")
runes[0] = 'П'
str3 := string(runes)

Эффективная работа со строками

Из-за иммутабельности частая конкатенация строк создает множество промежуточных объектов. Для эффективной сборки строк используйте strings.Builder:

var builder strings.Builder
builder.Grow(100) // Предварительное выделение памяти повышает производительность

for i := 0; i < 10; i++ {
    builder.WriteString("строка")
    builder.WriteByte(' ')
}

result := builder.String() // Единое преобразование в конце

Пакеты для работы со строками

Go предоставляет богатую стандартную библиотеку:

• strings — основные операции со строками (поиск, замена, разделение и т.д.)
• strconv — преобразование строк в другие типы и обратно
• unicode и unicode/utf8 — работа с символами Unicode
• regexp — регулярные выражения
• bytes — аналоги strings, но для слайсов байт

import "strings"

// Пример использования пакета strings
s := "   Hello, World!   "
trimmed := strings.TrimSpace(s) // "Hello, World!"
upper := strings.ToUpper(s) // "   HELLO, WORLD!   "
parts := strings.Split("a,b,c", ",") // []string{"a", "b", "c"}

Строковые литералы и интерпретация

Go поддерживает несколько видов строковых литералов:

// Интерпретируемая строка (поддерживает escape-последовательности)
s1 := "Hello\nWorld\t!"

// Сырая строка (raw string, без интерпретации escape-последовательностей)
s2 := `Hello\nWorld\t!` // Буквально содержит \n и \t

// Многострочные строки (только с использованием обратных кавычек)
s3 := `Это
многострочная
строка`

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

Сравнение строк в Go выполняется побайтово и является лексикографическим:

fmt.Println("abc" < "abd") // true
fmt.Println("a" == "a")    // true

Из-за иммутабельности сравнение строк выполняется быстро, так как компилятор может оптимизировать проверку равенства через сравнение указателей, если это возможно.

Критические моменты для разработчика

1. Индексация возвращает байты, а не символы — используйте for range для итерации по символам
2. Длина строки (len()) возвращает количество байт, а не символов — для подсчета символов используйте utf8.RuneCountInString()
3. Изменение строк требует преобразования в []byte или []rune и обратно
4. Конкатенация в цикле неэффективна — используйте strings.Builder
5. Строки могут содержать любые байты, не только валидный UTF-8 — проверяйте при необходимости

Понимание этих особенностей позволяет избежать распространенных ошибок, таких как некорректная обработка многобайтовых символов или проблемы с производительностью при интенсивной работе со строками.