5 ЛОВУШЕК по СТРОКАМ с СОБЕСЕДОВАНИЯ на GOLANG разработчика

23 июня 2026 г. · 45 мин. чтения

Сегодня мы разберем обучающее видео от разработчика и ментора Димурина, посвященное семи ключевым ловушкам работы со строками в Go. Автор наглядно демонстрирует разницу между байтами и рунами, подводные камни функции len, итерации через range, иммутабельность строк и эффективную конкатенацию через strings.Builder. Разбор сопровождается примерами кода и объяснением внутренней структуры строки, что делает материал полезным для подготовки к техническим собеседованиям как новичкам, так и опытным разработчикам.

Вопрос 1. Что представляет собой строка в Go и как она реализована?

Таймкод: <YouTubeSeekTo id="vo1kWaEGzt4" time="00:00:21"/>

Ответ собеседника: Правильный. Строка в Go — это неизменяемая последовательность байт, реализованная как структура с двумя полями: указатель на массив байт и длина строки. Байты кодируются в UTF-8, один символ может занимать от 1 до 4 байт.

Правильный ответ:

1. Внутреннее представление (String Header) В рантайме Go строка представлена структурой reflect.StringHeader (в пакете runtime это stringStruct):

type StringHeader struct {
    Data uintptr // указатель на начало байтового массива
    Len  int     // длина строки в байтах
}

Это value type (тип-значение): при присваивании или передаче в функцию копируется только сама структура (16 байт на 64-битных системах), а не сами данные. Базовый массив байт остается общим (read-only).

2. Ключевые свойства

Неизменяемость (Immutability): Содержимое базового массива нельзя изменить после создания строки. Любая «модификация» (конкатенация, замена подстроки) приводит к аллокации новой строки и копированию данных.
Кодировка UTF-8: Исходный код Go файлов и строковые литералы всегда в UTF-8. Однако тип string на уровне рантайма не валидирует корректность UTF-8 — это просто []byte с семантикой текста. Невалидные последовательности байт допустимы (хотя и не рекомендуются).
Нулевое значение: Пустая строка "" — это StringHeader{Data: 0, Len: 0}. Указатель Data может быть nil (0) только для пустой строки.

3. Рун (Rune) vs Байт

byte (uint8) — единица хранения (1 байт).
rune (int32) — кодовая точка Unicode (Code Point).
Один видимый символ (графема) может состоять из нескольких рун (например, флаги стран — 2 руны, эмодзи с модификаторами кожи — несколько рун).
Итерация for range s идет по рунам (декодируя UTF-8), а len(s) и индексация s[i] — по байтам.

s := "Привет" // 6 рун, 12 байт (кириллица = 2 байта на руну)
fmt.Println(len(s))        // 12
fmt.Println(utf8.RuneCountInString(s)) // 6

// Итерация по рунам
for i, r := range s {
    fmt.Printf("Позиция байта %d: руна %U '%c'\n", i, r, r)
}
// Индексация по байтам
fmt.Printf("Первый байт: %x\n", s[0]) // 0xd0 (не 'П'!)

4. Конвертации и аллокации

string <-> []byte: Всегда копирует данные (кроме небезопасных хаков через unsafe или runtime.stringtoslicebyte в новых версиях для read-only сценариев, но официально — копия).
string <-> []rune: Копирует и декодирует/кодирует UTF-8.
strings.Builder / bytes.Buffer: Эффективные способы сборки строк без промежуточных аллокаций.

5. Сравнение строк Сравнение == / != / < работает за O(min(len(a), len(b))). Сначала сравниваются длины (быстрый путь), затем побайтово (лексикографически по кодовым единицам UTF-8). Для ASCII это совпадает с лексикографическим порядком кодовых точек.

6. Интернинг (String Interning) Компилятор и линкер могут объединять одинаковые строковые литералы в один экземпляр в read-only секции бинарника (.rodata). Это оптимизация, на которую нельзя полагаться в логике программы (адреса могут отличаться для динамически созданных строк).

7. Пример небезопасной «мутации» (только для понимания устройства, в продакшене так делать нельзя)

import "unsafe"

func mutateString(s *string) {
    // Получаем доступ к заголовку
    hdr := (*reflect.StringHeader)(unsafe.Pointer(s))
    // Приводим указатель на данные к слайсу байт
    // ВНИМАНИЕ: нарушается неизменяемость, GC не ожидает изменений в этой памяти
    data := unsafe.Slice((*byte)(unsafe.Pointer(hdr.Data)), hdr.Len)
    if len(data) > 0 {
        data[0] = 'X'
    }
}

Последствия: Нарушается контракты языка, ломаются хеш-таблины (map keys), строковые константы в .rodata вызывают SIGSEGV при записи, кэш процессора и оптимизации компилятора дают неопределенное поведение.

Резюме для интервью: Строка в Go — это неизменяемая структура-заголовок (указатель + длина), ссылающаяся на байтовый массив в памяти (обычно в куче или .rodata). Она UTF-8 agnostic на уровне байт, но стандартная библиотека (unicode/utf8, strings, for range) предоставляет инструменты для работы с рунами. Главное практическое следствие: конкатенация в цикле s += "x" — это O(N²) аллокаций, используйте strings.Builder.

Вопрос 2. Что такое руна (rune) в Go и чему она соответствует?

Таймкод: <YouTubeSeekTo id="vo1kWaEGzt4" time="00:00:52"/>

Ответ собеседника: Правильный. Руна — это алиас над типом int32. Каждая руна соответствует конкретному символу в кодировке Unicode (диапазон 0–1 100 000).

Правильный ответ:

1. Определение и тип

type rune = int32

rune — это псевдоним (alias) для int32. Он используется для явного указания семантики: «это значение представляет собой кодовую точку Unicode (Unicode Code Point)», а не просто число.

2. Соответствие Unicode Code Point Руна хранит числовой идентификатор символа в таблице Unicode (Code Point).

Диапазон значений: U+0000 ... U+10FFFF (1 114 112 возможных значений).
Суррогатные пары (Surrogate Halves) U+D800–U+DFFF (0xD800–0xDFFF) не являются валидными рунами — они зарезервированы для UTF-16 и не могут встречаться в корректном UTF-8/Go строке. Пакет unicode/utf8 считает их ошибкой декодирования (RuneError = 0xFFFD).

3. Рунa ≠ Байт ≠ Графема (Видимый символ) Это критически важное различие для Senior-уровня:

Уровень	Тип в Go	Размер	Что представляет
Хранилище	`byte` (`uint8`)	1 байт	Кодовая единица UTF-8 (Code Unit). Строка — это `[]byte`.
Логический символ	`rune` (`int32`)	4 байта	Кодовая точка Unicode (Code Point). Результат `for range string`.
Пользовательский символ	—	1..N рун	Графема (Grapheme Cluster). То, что пользователь воспринимает как «один символ».

Примеры разницы:

// 1. Простой символ (ASCII)
s1 := "A"      // 1 байт, 1 руна, 1 графема

// 2. Кириллица / Латиница с диакритиками (BMP - Basic Multilingual Plane)
s2 := "Ё"      // 2 байта (0xD0 0x81), 1 руна (U+0401), 1 графема
s3 := "é"      // 2 байта (0xC3 0xA9), 1 руна (U+00E9), 1 графема
// Но можно записать как комбинацию:
s3b := "e\u0301" // 3 байта, 2 руны (U+0065 'e' + U+0301 ' ́'), 1 графема!

// 3. Эмодзи за пределами BMP (Supplementary Planes)
s4 := "😀"     // 4 байта (F0 9F 98 80), 1 руна (U+1F600), 1 графема

// 4. Сложные эмодзи (Zero Width Joiner / Modifiers) -> НЕСКОЛЬКО РУН = 1 ГРАФЕМА
s5 := "👨‍👩‍👧‍👦"   // Семья: 4 человека, связаны ZWJ (U+200D)
// Байт: ~25, Рун: 11 (Man + ZWJ + Woman + ZWJ + Girl + ZWJ + Boy), Графем: 1

// 5. Флаги (Regional Indicator Symbols) -> 2 РУНЫ = 1 ГРАФЕМА
s6 := "🇷🇺"      // 8 байт, 2 руны (U+1F1F7 'R' + U+1F1FA 'U'), 1 графема

4. Итерация и доступ: Главная ловушка

s := "Привет" // 12 байт, 6 рун

// for range — декодирует UTF-8 -> итерирует по РУНАМ (Code Points)
for i, r := range s {
    // i — индекс БАЙТА, где начинается руна
    // r — руна (int32)
    fmt.Printf("Byte index %d: Rune %U '%c'\n", i, r, r)
}
// Вывод: Byte index 0, Byte index 2, Byte index 4... (шаг 2 байта)

// Индексация s[i] — доступ к БАЙТАМ (Code Units)
fmt.Println(s[0]) // 208 (0xD0) — первый байт 'П', НЕ руна 'П' (1055 / 0x41F)
fmt.Printf("%c\n", s[0]) // 'Ð' (мусор с точки зрения текста)

// Получение руны по индексу байта — ручное декодирование:
r, size := utf8.DecodeRuneInString(s[0:])
// r == 'П', size == 2

5. Конвертации и аллокации

[]rune(s): Декодирует всю строку в слайс рун. O(N) по памяти и времени, аллоцирует новый слайс []int32 (4 байта на руну).
string(runeSlice): Кодирует слайс рун в UTF-8 байты. Проверяет валидность рун (невалидные заменяет на RuneError `` / 0xFFFD).
utf8.RuneCountInString(s): Считает руны за O(N) без аллокации слайса (проходит по байтам, декодируя на лету).

6. Практический совет: как работать с «символами» пользователя? Стандартная библиотека Go (strings, unicode) работает на уровне рун (Code Points). Для работы с графемами (то, что видит пользователь: курсор движется по графемам, бэкспейс удаляет графему) нужны сторонние библиотеки, например:

github.com/rivo/uniseg (Grapheme Cluster segmentation).
golang.org/x/text/unicode/norm (Нормализация NFC/NFD — критично для сравнения строк: é (1 руна) vs e\u0301 (2 руны) — визуально одинаковы, бинарно разные).

Резюме для интервью: > rune = int32 = Unicode Code Point. > Строка в Go — это последовательность байт (UTF-8 Code Units). > for range и []rune(s) дают последовательность Code Points. > Один видимый символ (графема) может состоять из нескольких рун (эмоции с модификаторами, флаги, комбинируемые диакритики). > Индексация s[i] возвращает байт, а не руну/символ.

Вопрос 3. Что возвращает функция len() при вызове от строки, содержащей не-ASCII символы?

Таймкод: <YouTubeSeekTo id="vo1kWaEGzt4" time="00:02:06"/>

Ответ собеседника: Правильный. Функция len() возвращает количество байт в массиве, а не количество символов. Для русских букв (2 байта каждый) слово «привет» (6 символов) вернёт 12.

Правильный ответ:

1. Семантика len(s) для строк Функция len(s) возвращает количество байт в базовом массиве строки (поле Len в StringHeader).

Сложность: O(1). Это просто чтение поля структуры, никакого прохода по памяти.
Для ASCII-строк (где 1 символ = 1 байт) результат совпадает с количеством символов.
Для не-ASCII (UTF-8 multibyte) результат больше количества рун (Code Points) и значительно больше количества графем (видимых символов).

2. UTF-8 кодировка и размеры рун Go использует UTF-8. Размер руны в байтах зависит от её числового значения (Code Point):

Диапазон Code Point	Блок Unicode	Байт в UTF-8	Пример
`U+0000` – `U+007F`	ASCII (Basic Latin)	1	`A` (65), `0` (48), `\n`
`U+0080` – `U+07FF`	Latin Extended, Кириллица, Греческая, Арабская, Еврейская	2	`Ё` (U+0401), `é` (U+00E9), `α` (U+03B1)
`U+0800` – `U+FFFF`	BMP (Basic Multilingual Plane): Китайские иероглифы, Корейская, Японская (Кандзи), Эмодзи (базовые)	3	`中` (U+4E2D), `가` (U+AC00), `☕` (U+2615)
`U+10000` – `U+10FFFF`	Supplementary Planes: Редкие иероглифы, Исторические письма, Большинство эмодзи	4	`😀` (U+1F600), `🇷🇺` (флаг = 2 руны по 4 байта = 8 байт)

3. Практические примеры

package main

import (
	"fmt"
	"unicode/utf8"
)

func main() {
	// 1. Чистый ASCII
	s1 := "hello"
	fmt.Printf("'%s': len=%d, runes=%d\n", s1, len(s1), utf8.RuneCountInString(s1))
	// len=5, runes=5

	// 2. Кириллица (2 байта на руну)
	s2 := "привет" // 6 рун
	fmt.Printf("'%s': len=%d, runes=%d\n", s2, len(s2), utf8.RuneCountInString(s2))
	// len=12, runes=6

	// 3. Смешанная строка
	s3 := "Go_Привет_😀" // 2 (Go) + 1 (_) + 12 (Привет) + 1 (_) + 4 (😀) = 20 байт
	// Рун: 2 + 1 + 6 + 1 + 1 = 11
	fmt.Printf("'%s': len=%d, runes=%d\n", s3, len(s3), utf8.RuneCountInString(s3))
	// len=20, runes=11

	// 4. Комбинируемые символы (диакритика) -> 2 руны, 1 графема
	s4 := "e\u0301" // 'e' + combining acute accent
	fmt.Printf("'%s': len=%d, runes=%d\n", s4, len(s4), utf8.RuneCountInString(s4))
	// len=3 (1+2), runes=2

	// 5. ZWJ Sequence (Emoji ZWJ Sequence) -> Много рун, 1 графема
	s5 := "👨‍👩‍👧‍👦" // Family emoji
	fmt.Printf("Family: len=%d, runes=%d\n", len(s5), utf8.RuneCountInString(s5))
	// len ~ 25 байт, runes = 11 (Man + ZWJ + Woman + ZWJ + Girl + ZWJ + Boy)
}

4. Типичные ошибки и ловушки

А. Индексация s[i]

s := "Привет"
// s[0] -> byte 0xD0 (первый байт 'П'), тип byte (uint8)
// s[1] -> byte 0x9F (второй байт 'П')
// s[2] -> byte 0xD0 (первый байт 'р')
// ОШИБКА: s[0] != 'П' (rune 1055)

Правило: s[i] дает i-й байт, а не i-й символ/руну.

Б. Срезание строк s[i:j] Срезание работает по индексам байт.

s := "Привет"
// s[0:2] -> "П" (первые 2 байта = 1 руна) — ОК
// s[0:1] -> "\xD0" (невалидная UTF-8 строка, половина руны) — ПРОБЛЕМА
// s[0:3] -> "П" + первый байт 'р' (невалидная UTF-8) — ПРОБЛЕМА

Правило: Срезать строки можно только по границам рун (индексы, полученные из for range или utf8.DecodeRuneInString). Иначе получите невалидную UTF-8 строку.

В. Итерация for range

s := "Привет"
for i, r := range s {
    // i = 0, 2, 4, 6, 8, 10 (индексы БАЙТ)
    // r = руны 'П', 'р', 'и', 'в', 'е', 'т'
}

Индекс i в for range — это байтовый оффсет начала текущей руны.

5. Как правильно получить «длину в символах»?

Задача	Функция / Метод	Сложность	Аллокации
Кол-во байт	`len(s)`	O(1)	Нет
Кол-во рун (Code Points)	`utf8.RuneCountInString(s)`	O(N)	Нет (один проход по байтам)
Кол-во рун (если слайс уже нужен)	`len([]rune(s))`	O(N)	Да (создает `[]int32`)
Кол-во графем (видимых символов)	`github.com/rivo/uniseg`	O(N)	Да (нужен внешний пакет)

Резюме для интервью: > len(string) — это O(1) операция, возвращающая размер в байтах базового массива. > Для не-ASCII (UTF-8) len(s) > utf8.RuneCountInString(s). > Кириллица = 2 байта/руна, Базовые эмодзи/Иероглифы = 3-4 байта/руна, Сложные эмодзи (ZWJ, флаги) = много байт на одну графему. > Никогда не используйте len(s) для валидации длины ввода пользователя (лимиты форм, БД VARCHAR(N) в символах) — используйте utf8.RuneCountInString или счетчики графем.

Вопрос 4. Как получить количество символов (рун) в строке?

Таймкод: <YouTubeSeekTo id="vo1kWaEGzt4" time="00:02:25"/>

Ответ собеседника: Правильный. Нужно преобразовать строку в срез рун ([]rune) и вызвать len(), либо использовать функцию utf8.RuneCountInString().

Правильный ответ:

1. Основные способы

Способ	Код	Сложность	Аллокации памяти	Когда использовать
Стандартный (Best Practice)	`utf8.RuneCountInString(s)`	O(N)	Нет (0 B/op)	По умолчанию. Единственный способ получить счет без нагрузки на GC.
Через конвертацию	`len([]rune(s))`	O(N)	Да (N * 4 байт + overhead слайса)	Только если вам нужен сам слайс `[]rune` для дальнейшей работы (мутации, случайный доступ по индексу руны).
Ручное декодирование	`for range s { count++ }`	O(N)	Нет	Редко, если нужна кастомная логика внутри цикла (например, пропуск определенных рун).

2. Детальный разбор utf8.RuneCountInString (Рекомендуемый)

import "unicode/utf8"

func CountRunes(s string) int {
    // Внутри: проход по байтам строки, декодирование рун через DecodeRune
    // Аналогично: for range s { count++ }
    return utf8.RuneCountInString(s)
}

Производительность: Один линейный проход по байтам строки (O(N) байт). Внутренне использует utf8.DecodeRune (оптимизированный на ассемблере для большинства архитектур).
Память: Zero allocation. Не создает временных объектов. Критично для хотовых путей (hot paths), парсеров, обработки больших текстов.

3. Детальный разбор len([]rune(s)) (Конвертация)

func CountRunesViaSlice(s string) int {
    // 1. Аллоцирует новый слайс []int32 емкостью len(s) (в худшем случае)
    // 2. Копирует туда декодированные руны
    // 3. Возвращает длину слайса
    return len([]rune(s))
}

Аллокация: Создает слайс []rune (под капотом []int32). Размер = Кол-во_рун * 4 байта.
Нагрузка на GC: Каждый вызов = мусор в куче. В цикле или на горячем пути — утечка производительности (GC pressure).
Польза: Дает случайный доступ к руне по индексу runes[i] за O(1). Если нужно s[5] как руна — конвертируйте один раз, храните слайс.

4. Бенчмарк для понимания масштаба (примерный)

// go test -bench=. -benchmem
func BenchmarkRuneCount(b *testing.B) {
    s := strings.Repeat("Привет, мир! 😀 ", 1000) // ~20 KB, много не-ASCII
    b.ReportAllocs()
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        _ = utf8.RuneCountInString(s)
    }
}

func BenchmarkRuneSliceLen(b *testing.B) {
    s := strings.Repeat("Привет, мир! 😀 ", 1000)
    b.ReportAllocs()
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        _ = len([]rune(s))
    }
}

/*
Результаты (ориентировочно):
BenchmarkRuneCount       50000   30000 ns/op    0 B/op   0 allocs/op  <-- Идеально
BenchmarkRuneSliceLen     5000   250000 ns/op   80 KB/op  1 allocs/op <-- x8 медленнее, аллоцирует
*/

5. Важное уточнение: Рунy ≠ Пользовательские символы (Графемы)

Оба метода выше считают Unicode Code Points (Руны). Для строк с комбинирующими символами, эмодзи ZWJ-последовательностями или флагами результат будет не соответствовать тому, что видит пользователь.

s := "e\u0301"          // é как 'e' + комбинирующий акцент (2 руны, 1 графема)
s2 := "👨‍👩‍👧‍👦"         // Семья (11 рун, 1 графема)
s3 := "🇷🇺"             // Флаг (2 руны, 1 графема)

fmt.Println(utf8.RuneCountInString(s))  // 2
fmt.Println(utf8.RuneCountInString(s2)) // 11
fmt.Println(utf8.RuneCountInString(s3)) // 2

Для подсчета «видимых символов» (Grapheme Clusters) нужен внешний пакет:

// go get github.com/rivo/uniseg
import "github.com/rivo/uniseg"

gr := uniseg.NewGraphemes(s2)
count := 0
for gr.Next() {
    count++
}
fmt.Println(count) // 1 для семьи, 1 для флага, 1 для "é"

6. Паттерн: «Конвертируй один раз, используй много раз»

Если алгоритм требует множественного доступа по индексу руны (например, парсер, работающий с курсором):

func ProcessString(s string) {
    // ПЛОХО: O(N^2) если делать в цикле len([]rune(s)) или доступ по индексу через utf8.DecodeRuneInString
    // for i := 0; i < utf8.RuneCountInString(s); i++ { r, _ := utf8.DecodeRuneInString(s[i:]) ... } 

    // ХОРОШО: Один проход, одна аллокация, далее O(1) доступ
    runes := []rune(s) // Аллоцируем ОДИН РАЗ
    for i := 0; i < len(runes); i++ {
        r := runes[i] // Мгновенный доступ
        // ... логика ...
    }
}

Резюме для интервью: > По умолчанию — только utf8.RuneCountInString(s). Это O(N) по времени, O(1) по памяти (нет аллокаций). > len([]rune(s)) — антипаттерн для простого подсчета (аллоцирует []int32, нагружает GC). Используйте только если нужен слайс рун для дальнейшей работы (случайный доступ, модификация). > Помните: это Code Points, не Графемы. Для UI/валидации длины «видимых символов» используйте github.com/rivo/uniseg.

Вопрос 5. Что возвращается при обращении к строке по индексу `s[i]`?

Таймкод: <YouTubeSeekTo id="vo1kWaEGzt4" time="00:03:43"/>

Ответ собеседника: Правильный. Возвращается байт (uint8), а не символ. Для многобайтовых символов это будет только часть символа.

Правильный ответ:

1. Фундаментальное правило

s := "Привет"
b := s[0] // Тип: byte (alias uint8), Значение: 0xD0 (первый байт 'П')

Операция индексации строки s[i] в Go возвращает byte (беззнаковый 8-битный целочисленный тип), а не rune (символ/кодпоинт) и не string.

2. Почему так сделано? (Архитектура строки)

Строка в Go — это immutable (неизменяемая) структура-заголовок (StringHeader), указывающая на массив байт (read-only):

type StringHeader struct {
    Data uintptr // указатель на байты
    Len  int     // длина в БАЙТАХ
}

len(s) → Len (байты).
s[i] → *(Data + i) (прямое чтение i-го байта из памяти).
O(1) время, нулевые накладные расходы (нет декодирования UTF-8).

3. Последствия для не-ASCII (UTF-8)

Кириллица (2 байта на руну)

s := "А" // Unicode U+0410, UTF-8: 0xD0 0x90 (2 байта)
fmt.Printf("%08b %08b\n", s[0], s[1]) 
// Вывод: 11010000 10010000 (0xD0, 0x90)
// s[0] = 0xD0 — это НЕ 'А', это первый байт последовательности.

Иероглифы / Базовые эмодзи (3-4 байта)

s := "中" // U+4E2D, UTF-8: 0xE4 0xB8 0xAD (3 байта)
s[0] // 0xE4
s[1] // 0xB8
s[2] // 0xAD

Сложные эмодзи (Последовательности)

s := "👨‍👩‍👧‍👦" // Семья: Man + ZWJ + Woman + ZWJ + Girl + ZWJ + Boy
// ~25 байт, 11 рун
s[0] // 0xF0 (первый байт первого кодпоинта U+1F468)

4. Типичные ошибки (Anti-patterns)

А. Сравнение с руной/символом

s := "Привет"
if s[0] == 'П' { // ОШИБКА КОМПИЛЯЦИИ: mismatched types byte (uint8) and rune (int32)
    // ...
}
if s[0] == 0xD0 { // КОМПИЛИРУЕТСЯ, но бессмысленно логически
}

Б. Срезание строки `s[i:j]` по индексам рун

s := "Привет"
r := s[0:2] // "Пр" (2 руны = 4 байта) — СЧАСТЛИВЫЙ СЛУЧАЙ
r := s[0:3] // "П" + первый байт 'р' (0xD1) — НЕВАЛИДНАЯ UTF-8 СТРОКА!
fmt.Println(r) // Вывод: "П" (заменительный символ )

Правило: Срезать строку s[i:j] можно только по границам рун (индексы, полученные через for range или utf8.DecodeRuneInString).

В. Итерация по байтам вместо рун

// ПЛОХО: Итерируем байты
for i := 0; i < len(s); i++ {
    fmt.Print(s[i], " ") // Выведет байты: 212 144 213 128 ...
}

// ХОРОШО: for range декодирует руны
for _, r := range s {
    fmt.Printf("%c ", r) // Выведет: П р и в е т
}

5. Как правильно получить i-ю руну (Code Point)

Вариант А: `for range` (Идиоматично, O(N) для прохода до i)

func NthRune(s string, n int) (rune, bool) {
    for i, r := range s {
        if i == n {
            return r, true
        }
    }
    return 0, false
}

Вариант Б: `utf8.DecodeRuneInString` (Ручное декодирование, O(N) для поиска индекса)

import "unicode/utf8"

func NthRuneManual(s string, n int) (rune, int) {
    for i := 0; i < n; i++ {
        _, size := utf8.DecodeRuneInString(s)
        s = s[size:] // Сдвигаем срез байтов
    }
    return utf8.DecodeRuneInString(s)
}

Вариант В: Конвертация в `[]rune` (O(N) память + время, но O(1) доступ)

runes := []rune(s) // Однократная аллокация
r := runes[n]      // Мгновенный доступ по индексу

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

6. Как получить i-й байт (если это действительно нужно)

Работа с бинарными протоколами, парсинг raw-байтов, хэширование:

b := s[i]        // byte (uint8)
bs := s[i:j]     // string (подстрока байтов, zero-copy)
bs := []byte(s)  // []byte (копия данных, для мутации)

7. Резюме для собеседования (Cheat Sheet)

Выражение	Тип результата	Содержимое	Сложность	Валидность UTF-8 результата
`s[i]`	`byte` (`uint8`)	i-й байт	O(1)	N/A (это байт)
`s[i:j]`	`string`	Байты с i по j-1	O(1) (zero-copy)	Только если i, j — границы рун
`s[i:]`	`string`	Суффикс байтов	O(1)	Только если i — граница руны
`[]rune(s)`	`[]rune` (`[]int32`)	Все руны	O(N) байт, аллокация	Всегда валидные руны
`for _, r := range s`	`rune` (`int32`)	Руны по порядку	O(N) байт	Всегда валидные руны

Ключевая фраза: > «Строка в Go — это read-only слайс байт. Индексация дает байт. for range — это синтаксический сахар над UTF-8 декодером, выдающий руны».

Вопрос 6. Как работает цикл `for range` по строке?

Таймкод: <YouTubeSeekTo id="vo1kWaEGzt4" time="00:04:02"/>

Ответ собеседника: Правильный. Цикл for range итерирует по рунам (символам), а не по байтам. Первая переменная — индекс начала руны в байтах, вторая — сама руна (int32). Индексы могут «прыгать» на размер руны в байтах.

Правильный ответ:

1. Сигнатура и семантика

for byteIndex, runeValue := range str {
    // byteIndex: int    — байтовый.offset (начало текущей руны)
    // runeValue: rune   — Unicode Code Point (int32)
}

Итерирует по рунам (Code Points), декодируя UTF-8 на лету.
Порядок: Слева направо (от младших байтовых индексов к старшим).
Копирование: Строка str копируется в заголовок цикла (структура StringHeader — 16 байт: указатель + длина). Базовый массив байт не копируется (zero-copy).

2. Внутренняя реализация (Псевдокод компилятора)

for range над строкой разворачивается в конструкцию, эквивалентную ручному декодированию через unicode/utf8:

// Внутренний вид range string
s := str           // копия заголовка строки (ptr, len)
for i := 0; i < len(s); {
    // 1. Декодируем руну в текущей позиции
    r, size := utf8.DecodeRuneInString(s[i:])
    
    // 2. Обработка невалидного UTF-8 (RuneError = U+FFFD )
    if r == utf8.RuneError && size == 1 {
        // Невалидная последовательность — пропускаем 1 байт
    }
    
    // 3. Вызов тела цикла
    byteIndex = i
    runeValue = r
    // ... body ...
    
    // 4. Сдвиг на размер руны в байтах
    i += size
}

Ключевой момент: Инкремент индекса i += size, а не i++. Поэтому byteIndex «прыгает»: 0, 2, 4... для кириллицы; 0, 3, 6... для иероглифов.

3. Поведение на невалидном UTF-8

Go строки могут содержать произвольные байты (не только валидный UTF-8). for range — это устойчивый декодер:

Входные байты	`runeValue`	`size`	`byteIndex` следующий
Валидная руна (напр. `0xD0 0x9F`)	`U+041F` ('П')	2	`i + 2`
Невалидная последовательность (напр. `0xFF 0xFE`)	`utf8.RuneError` (`U+FFFD` )	1	`i + 1`
Одиночный `0x80` (continuation byte без стартового)	`U+FFFD`	1	`i + 1`

> Важно: Цикл никогда не паникует и никогда не зацикливается на плохом UTF-8. Он гарантированно пройдет len(s) байт, заменяя ошибки на RuneError и продвигаясь на 1 байт.

4. Паттерны использования и ловушки

А. Игнорирование индекса (частый кейс)

for _, r := range s {
    // r — руна. Индекс байтов не нужен.
}

Б. Ручной контроль индекса (например, парсинг с возвратом назад)

i := 0
for i < len(s) {
    r, size := utf8.DecodeRuneInString(s[i:])
    // ... логика ...
    i += size // Полный контроль шага
}

В. Ловушка: Модификация строки внутри цикла

s := "abc"
for i, r := range s {
    if i == 1 {
        s = "xyz" // ИЗМЕНЕНИЕ ПЕРЕМЕННОЙ s
        fmt.Println("Changed s to", s)
    }
    fmt.Printf("i=%d r=%c\n", i, r)
}
// Вывод:
// i=0 r=a
// i=1 r=b
// Changed s to xyz
// i=2 r=c  <-- ЦИКЛ ПРОДОЛЖИЛ ПО СТАРОЙ СТРОКЕ!

Почему: range захватил копию заголовка строки (ptr, len) в момент входа в цикл. Переприсваивание s = "xyz" меняет только локальную переменную s вне цикла, не затрагивая итератор.

Г. Ловушка: `range` по `[]byte` vs `string`

s := "А" // 2 байта: 0xD0 0x90

// range string -> 1 итерация (руна)
for _, r := range s { fmt.Printf("%U ", r) } // U+0410

// range []byte -> 2 итерации (байты!)
for _, b := range []byte(s) { fmt.Printf("%02X ", b) } // D0 90

5. Производительность и оптимизации

Аспект	Детали
Скорость	~1-2 ns на руну (на современных CPU). `utf8.DecodeRuneInString` инлайнится и векторизуется компилятором.
Аллокации	Нет (кроме захвата переменных замыканием, если есть).
Кэш	Последовательное чтение памяти (prefetch-friendly).
Bounds Check	Компилятор (SSA) обычно устраняет проверку границ внутри `DecodeRuneInString`, так как цикл ограничен `len(s)`.

Сравнение с ручным декодированием:

// range string (Best Practice)
for _, r := range s { ... }

// Ручной цикл (то же самое, но вербознее)
for i := 0; i < len(s); {
    r, size := utf8.DecodeRuneInString(s[i:])
    // ...
    i += size
}

Компилятор генерирует идентичный машинный код для обоих вариантов. Используйте for range — это идиоматично и читаемо.

6. Когда `for range` НЕ подходит

Нужен доступ по индексу руны (случайный доступ): конвертируйте в []rune один раз.

Нужны графемы (Grapheme Clusters), а не кодпоинты: используйте github.com/rivo/uniseg.

// "e\u0301" -> 1 графема, 2 руны
g := uniseg.NewGraphemes("e\u0301")
for g.Next() { fmt.Println(g.Str()) } // 1 итерация

Парсинг бинарных протоколов в строке (редкий кейс): используйте []byte(s) или strings.Reader / bufio.Reader.

7. Резюме для собеседования (Cheat Sheet)

Характеристика	`for range string`
Единица итерации	`rune` (Unicode Code Point, `int32`)
Индекс	`int` — байтовый оффсет начала руны
Шаг индекса	`+= size` (1..4 байта), не `++`
UTF-8 валидность	Не требуется. Невалидные байты -> `RuneError` (U+FFFD), шаг 1 байт.
Копирование данных	Нет (копируется только заголовок строки: 16 байт).
Безопасность данных	Итерация по снимку строки на момент старта цикла.
Сложность	O(N) по байтам (один проход).
Аллокации	0 (в чистом виде).

Ключевая фраза: > «for range по строке — это синтаксический сахар над utf8.DecodeRuneInString, который итерирует по кодпоинтам, выдает байтовые оффсеты и устойчив к невалидному UTF-8».

Вопрос 7. Являются ли строки в Go изменяемыми (mutable)?

Таймкод: <YouTubeSeekTo id="vo1kWaEGzt4" time="00:05:24"/>

Ответ собеседника: Правильный. Строки в Go иммутабельны (неизменяемы). Попытка изменить символ по индексу вызовет ошибку компиляции.

Правильный ответ:

1. Официальный ответ: Нет, строки неизменяемы (Immutable)

На уровне языка (Compile-time):

s := "hello"
s[0] = 'H' // ОШИБКА КОМПИЛЯЦИИ: cannot assign to s[0] (strings are immutable)

Оператор индексации s[i] для строки возвращает rvalue (значение byte), а не lvalue (адресуемую ячейку памяти). У него нет адреса (&s[0] также ошибка), поэтому запись в него запрещена синтаксически.

На уровне рантайма (Memory Layout): Базовый массив байт, на который указывает StringHeader.Data, размещается в Read-Only памяти (для литералов — секция .rodata бинарника, для динамических строк — куча с флагом read-only / защита через GC/OS). Попытка записи через unsafe приведет к SIGSEGV (Segmentation Fault).

2. Что на практике означает «Immutable»?

Операция	Результат	Комментарий
`s[i] = b`	Compile Error	Нельзя изменить байт.
`s += "world"`	Новая строка	Создается новый массив, копируются старые данные + добавление. Старая строка не меняется.
`strings.Replace(s, "a", "b", 1)`	Новая строка	Все функции `strings`/`bytes` возвращают новые значения.
Передача в функцию `func f(s string)`	Копия заголовка	Копируется `StringHeader` (16 байт: ptr + len). Данные не копируются (shared read-only).

3. Почему так сделано? (Design Rationale)

Безопасность параллелизма (Concurrency Safety): Строки можно свободно передавать между горутинами без мьютексов, атомиков или копирования данных. Read-only = Thread-safe by default.
Интернинг и дедупликация (String Interning): Компилятор/линкер могут объединять одинаковые литералы в один экземпляр в .rodata. Если бы строки были мутабельны, это было бы невозможно (или требовало бы Copy-on-Write, что дорого).
Ключи Map (Map Keys): Ключи map[string]T должны быть сравнимы и стабильны. Если бы строку можно было мутировать после вставки в мапу, хеш-код и равенство изменились бы, сломав инварианты хеш-таблицы (ключ «потерялся» бы).
Производительность (Zero-Cost Substring / Passing): Срезание s[i:j] и передача по значению — это O(1) копия заголовка. Мутабельность требовала бы Copy-on-Write (CoW) или постоянного клонирования, убивая производительность.

4. Как «изменить» строку? (Паттерны)

Поскольку мутации запрещены, используются паттерны сборки нового значения:

А. Конкатенация (для единичных случаев)

s := "a" + "b" + "c" // Компилятор оптимизирует в одну аллокацию (SSA)
s = s + "d"          // Новая аллокация, копирование старого + "d"

Осторожно в циклах: s += "x" в цикле = O(N²) аллокаций и копирований.

Б. `strings.Builder` (Стандарт для сборки, High Performance)

import "strings"

func BuildString(parts []string) string {
    var b strings.Builder
    // Опционально: b.Grow(estimatedSize) — предварительная аллокация
    for _, p := range parts {
        b.WriteString(p) // Амортизированная O(1) запись
    }
    return b.String() // Zero-copy конвертация в string (unsafe cast внутри)
}

Внутренне использует []byte, который растет экспоненциально (2x).
b.String() делает zero-copy приведение []byte -> string (через unsafe), так как Builder гарантирует, что байты больше не будут изменены после вызова String().

В. `bytes.Buffer` (Устаревший, но еще встречается)

import "bytes"
var buf bytes.Buffer
buf.WriteString("data")
s := buf.String() // Тоже zero-copy (начиная с Go 1.12+)

strings.Builder предпочтительнее: он быстрее (нет лишних интерфейсов/локов) и API ужесточен под строки.

Г. Конвертация в `[]byte` для мутации (если нужно изменить «по месту»)

s := "hello"
b := []byte(s)      // АЛЛОКАЦИЯ + КОПИРОВАНИЕ данных
b[0] = 'H'          // Мутация копии
s = string(b)       // АЛЛОКАЦИЯ + КОПИРОВАНИЕ обратно в новую строку

Используйте редко. Две аллокации и два полных копирования. Для единичных правок — ок. В горячих путях — strings.Builder или bytes.Buffer.

5. Опасные трюки через `unsafe` (Только для понимания, НЕ В ПРОДЕ)

import "unsafe"

func MutateStringUnsafe(s *string, i int, c byte) {
    // Получаем указатель на данные через рефлексию/unsafe
    hdr := (*reflect.StringHeader)(unsafe.Pointer(s))
    // Снимаем защиту (если страница RW) или крашимся (если RO)
    ptr := unsafe.Pointer(hdr.Data)
    // ПИШЕМ В READ-ONLY ПАМЯТЬ -> SIGSEGV на литералах / константах
    // На динамических строках (heap) может сработать, но:
    // 1. Ломает GC (write barrier не сработает).
    // 2. Ломает интернинг (меняем общий литерал для всего процесса).
    // 3. Ломает ключи мап (хеш не пересчитается).
    *(*byte)(unsafe.Pointer(uintptr(ptr) + uintptr(i))) = c
}

Последствия UB (Undefined Behavior):

Краш (SIGSEGV) на строковых литералах.
Скрытые баги в мапах (ключи «исчезают»).
Проблемы с GC (write barriers).
Нарушение контрактов стандартной библиотеки.

6. Сравнение с другими языками

Язык	Строки	Механизм мутации
Go	Immutable	Сборка новых (`Builder`), конвертация в `[]byte`.
Java	Immutable	`StringBuilder` / `StringBuffer` (аналог `strings.Builder`).
Python	Immutable	Конкатенация (`+`), `join`, `io.StringIO`.
C++	`std::string` Mutable	SSO (Small String Optimization), CoW (устарел), прямая мутация `s[0]='a'`.
Rust	`String` (owned, mutable), `&str` (borrowed, immutable)	Явное разделение владения и заимствования.

7. Резюме для собеседования (Cheat Sheet)

Аспект	Деталь
Статус	Immutable (неизменяемые).
Ошибка мутации	Compile-time error (`cannot assign to s[i]`).
Память данных	Read-Only (`.rodata` для литералов, защищенная куча для динамических).
Передача в функцию	Копия заголовка (16 байт), данные не копируются (shared read-only).
Срезание `s[i:j]`	O(1), новый заголовок на тот же массив.
Эффективная сборка	`strings.Builder` (zero-copy `String()`).
Мутация байтов	Только через `[]byte(s)` -> мутация -> `string(b)` (2 аллокации, 2 копирования).
Главная выгода	Thread-safety, Map Keys safety, Zero-cost substrings, Interning.

Ключевая фраза: > «Строки в Go — это immutable value types. Любая "модификация" создает новую строку. Для эффективной сборки используйте strings.Builder, который делает zero-copy переход []byte -> string в конце».

Вопрос 8. Если преобразовать строку в `[]byte`, изменить слайс и преобразовать обратно, изменится ли исходная строка?

Таймкод: <YouTubeSeekTo id="vo1kWaEGzt4" time="00:06:03"/>

Ответ собеседника: Правильный. Нет, исходная строка не изменится. Преобразование string → []byte создаёт полную копию данных, поэтому изменения затрагивают только новый слайс.

Правильный ответ:

1. Короткий ответ: Нет, исходная строка не изменится.

s := "hello"
b := []byte(s) // АЛЛОКАЦИЯ + КОПИРОВАНИЕ
b[0] = 'H'     // Мутация копии
s2 := string(b) // АЛЛОКАЦИЯ + КОПИРОВАНИЕ (новая строка)

fmt.Println(s)  // "hello" (ОРИГИНАЛ НЕ ИЗМЕНИЛСЯ)
fmt.Println(s2) // "Hello"

Причина: Конвертация string -> []byte и []byte -> string в Go всегда выполняет копирование данных (кроме специальных оптимизаций компилятора/рантайма, о которых ниже).

2. Что происходит под капотом (Runtime Mechanics)

`string -> []byte` (runtime.stringtoslicebyte)

// Упрощенная логика runtime
func stringtoslicebyte(s string) []byte {
    // 1. Аллоцируем НОВЫЙ массив в куче (heap)
    b := rawbyteslice(len(s)) // make([]byte, len(s))
    // 2. Копируем данные из строки (Read-Only) в новый слайс (Read-Write)
    copy(b, s) 
    return b
}

Аллокация: Да (новый объект в куче).
Копирование: Да (memmove байт за байтом).
Сложность: O(N) по времени и памяти.

`[]byte -> string` (runtime.slicebytetostring)

func slicebytetostring(b []byte) string {
    // 1. Аллоцируем память под новую строку (в куче, Read-Only)
    // 2. Копируем байты из слайса в строку
    // 3. Возвращаем StringHeader на новую память
}

Аллокация: Да.
Копирование: Да.
Итог: Две полные аллокации и два полных копирования для одного «изменения» символа.

3. Почему так сделано? (Инварианты языка)

Immutability Garantee: Строки неизменяемы. Если бы []byte(s) делил память со строкой, мутация слайса ломала бы строку (нарушение контракта, проблемы с мапами, интернингом, concurrency safety).
Memory Safety: Базовый массив строки может лежать в Read-Only памяти (.rodata для литералов). Запись в него вызвала бы SIGSEGV.
GC Simplicity: Раздельные жизненные циклы — раздельные аллокации. GC не должен отслеживать «внутренние указатели» от слайса к строке и наоборот.

4. Исключения и оптимизации (Advanced / Senior Level)

А. Компиляторные оптимизации (Escape Analysis / SSA)

В очень узких случаях компилятор может убрать копирование, если доказывает, что исходная строка не используется дальше и не уходит в кучу (escape analysis).

func OptExample() string {
    s := "hello"           // Локальная строка
    b := []byte(s)         // Компилятор МОЖЕТ (но не обязан) сделать zero-copy здесь
    b[0] = 'H'
    return string(b)       // И здесь zero-copy обратно
}

Не полагайтесь на это в продакшн-коде. Это деталь реализации конкретной версии компилятора (Go 1.20+ делает это агрессивнее).

Б. `strings.Builder` — Официальный Zero-Copy Path

Это единственный гарантированный способ собрать строку из байт без финального копирования.

func EfficientBuild() string {
    var b strings.Builder
    b.WriteString("hello") // Пишем в внутренний []byte
    b.Grow(10)             // Опционально: резерв
    b.Bytes()[0] = 'H'     // МУТАЦИЯ ВНУТРЕННЕГО БУФЕРА (легально!)
    // b.String() делает unsafe cast []byte -> string БЕЗ КОПИРОВАНИЯ
    return b.String()      // Zero-copy conversion
}

Как это работает: Builder хранит []byte. String() делает *(*string)(unsafe.Pointer(&b)). Это безопасно, потому что контракт Builder гласит: после вызова String() буфер больше не используется для записи.

В. `unsafe` Хак (ОПАСНО, НЕ ДЛЯ ПРОДА)

func UnsafeMutate(s *string) {
    // ЛОМАЕТ БЕЗОПАСНОСТЬ ТИПОВ, МОЖЕТ УРОНИТЬ ПРОГРАММУ (SIGSEGV на литералах)
    hdr := (*reflect.StringHeader)(unsafe.Pointer(s))
    // Приводим указатель на Read-Only данные к []byte
    b := unsafe.Slice((*byte)(unsafe.Pointer(hdr.Data)), hdr.Len)
    b[0] = 'H' // BOOM на строковых литералах!
}

Последствия: Нарушение инвариантов GC (write barriers), ломаные мапы (ключи меняют хеш), краш на константах.

5. Производительность: Бенчмарк мысленный

Операция	Аллокации	Копирования	Use Case
`[]byte(s)` -> мутация -> `string(b)`	2 (слайс + строка)	2 (в слайс, в строку)	Разовые правки, прототипы.
`strings.Builder`	1 (внутренний буфер, растет 2x)	0 (на выходе)	Сборка строк в цикле, горячие пути.
`bytes.Buffer`	1	0 (на выходе, Go 1.12+)	Работа с `io.Reader/Writer`, бинарные данные.
`strings.Replace/Builder`	Зависит от реализации	Оптимизировано	Стандартные манипуляции.

6. Паттерн «Copy-on-Write» вручную (если очень нужно)

Если профиль показывает, что аллокация []byte — горячая точка, и строка большая, а менять нужно мало:

func ReplaceAt(s string, i int, c byte) string {
    if i < 0 || i >= len(s) { return s }
    if s[i] == c { return s } // Fast path: нет изменений -> нет аллокаций

    // Аллоцируем ОДИН раз под результат
    b := make([]byte, len(s))
    copy(b, s)    // 1 копирование
    b[i] = c      // Мутация
    return unsafe.String(&b[0], len(b)) // Go 1.20+: unsafe.String для zero-copy []byte->string
    // или string(b) // до 1.20 (второе копирование)
}

Примечание: unsafe.String (Go 1.20+) / unsafe.StringData позволяют делать zero-copy конвертацию []byte -> string безопасно, если гарантируете, что слайс не будет мутировать после.

7. Резюме для собеседования (Cheat Sheet)

Конвертация	Копирует данные?	Аллокация?	Безопасно?
`string -> []byte`	ДА (всегда* )	ДА	Да
`[]byte -> string`	ДА (всегда* )	ДА	Да
`strings.Builder` -> `String()`	НЕТ (zero-copy)	НЕТ (на выходе)	Да (по контракту)
`unsafe` cast	НЕТ	НЕТ	НЕТ (UB)

* За исключением компиляторных оптимизаций, которые не гарантируются спецификацией.

Ключевая фраза: > «Конвертация string <-> []byte в Go — это value semantics с полным копированием (O(N) память и время). Для мутаций в горячих путях используйте strings.Builder, который предоставляет гарантированный zero-copy переход []byte -> string через unsafe под капотом, сохраняя типобезопасность».

Вопрос 9. Что представляет собой индекс (первая переменная) в цикле `for range` по строке?

Таймкод: <YouTubeSeekTo id="vo1kWaEGzt4" time="00:06:51"/>

Ответ собеседника: Правильный. Это позиция начала руны в байтах (byte offset), а не порядковый номер символа. Для ASCII совпадает с номером, для Unicode — прыгает на размер руны.

Правильный ответ:

1. Суть: Это Byte Offset (Смещение в байтах)

s := "Привет" // 6 рун, 12 байт (кириллица = 2 байта/руна)

for i, r := range s {
    fmt.Printf("i=%d, rune=%U '%c'\n", i, r, r)
}

/* ВЫВОД:
i=0,   rune=U+041F 'П'  // Начало 1-й руны (байт 0)
i=2,   rune=U+0440 'р'  // Начало 2-й руны (байт 2)  <-- ПРЫЖОК +2
i=4,   rune=U+0438 'и'  // Начало 3-й руны (байт 4)  <-- ПРЫЖОК +2
i=6,   rune=U+0432 'в'  // ...
i=8,   rune=U+0435 'е'
i=10,  rune=U+0442 'т'
*/

Ключевой момент: i — это индекс байта в базовом массиве строки, с которого начинается текущая руна (Code Point). Это НЕ счетчик итераций (0, 1, 2...).

2. Почему так сделано? (Design Rationale)

O(1) доступ к байтам: Строка — это []byte под капотом. range должен эффективно итерироваться по байтам, декодируя UTF-8 на лету.
Нужен ли индекс руны? Если бы i был счетчиком рун (0, 1, 2...), мы бы потеряли информацию о байтовом смещении. А оно критично для:
- Срезания строки: s[i:j] работает только с байтовыми индексами.
- Работы с unsafe / syscall / io (передача указателей/смещений).
- Синхронизации с внешними системами (байтовые оффсеты в файлах, сети).
Получение номера руны: Если нужно — заводите счетчик вручную (idx++), это O(1) на итерацию.

3. Ловушки и Best Practices

А. Не используйте `i` для доступа к руне по индексу

// ОШИБКА: i - это байтовый оффсет, а не индекс руны
for i, r := range s {
    // r == rune(s[i]) - ТОЛЬКО ДЛЯ ПЕРВОЙ РУНЫ (i=0) И ASCII
    // Для "Привет": s[2] = 0x40 (второй байт 'П'), а не 'р'!
    fmt.Println(r == rune(s[i])) // false для i > 0 в non-ASCII
}

Б. Срезание строки внутри цикла — Только через `i`

// ПРАВИЛЬНО: используем байтовый оффсет i для среза
for i, r := range s {
    if r == 'и' {
        suffix := s[i:] // "ивет" - корректно, i указывает на начало руны
        fmt.Println(suffix)
        break
    }
}

В. Итерация только по рунам (индекс не нужен) — используйте `_`

for _, r := range s {
    // i отбрасывается, чище код, никаких соблазнов использовать i не по назначению
}

Г. Ручной декодинг (аналог `range` под капотом)

// Это то, что делает range внутри (упрощенно)
for i := 0; i < len(s); {
    r, size := utf8.DecodeRuneInString(s[i:])
    // ... используем r, size ...
    i += size // Прыгаем на размер руны в байтах
}

4. Сложные кейсы: Составные символы (Grapheme Clusters)

range итерирует по Рунам (Code Points), а не по Графемам (видимым символам).

s := "e\u0301" // 'é' как комбинация: 'e' (U+0065) + Combining Acute (U+0301)
// Визуально: 1 символ. В строке: 2 руны, 3 байта.

for i, r := range s {
    fmt.Printf("i=%d, rune=%U\n", i, r)
}
/* ВЫВОД:
i=0, rune=U+0065 'e'      // Байт 0
i=2, rune=U+0301 '́'      // Байт 2 (пропущен байт 1 - продолжение U+0301)
*/

Индекс i все равно корректно указывает на начало каждой руны в байтах.

5. Сравнение с другими языками (для контекста Senior)

Язык	`for c in str` / аналог	Что возвращает индекс/итератор
Go	`for i, r := range s`	Byte Offset (явное управление UTF-8)
Python 3	`for i, c in enumerate(s)`	Code Point Index (0, 1, 2...), `s[i]` -> `str` (Code Point)
Java	`for (int cp : str.codePoints().toArray())`	Code Point (int), нет индекса в байтах без `getBytes()`
Rust	`for (i, c) in s.char_indices()`	(Byte Offset, Char) — ИДЕНТИЧНО GO
C++	`for (char c : s)`	Byte/Code Unit (char), ручной UTF-8 decode нужен

Go и Rust выбрали один подход: прозрачность UTF-8 хранения. Индекс = байт. Это самый честный и производительный подход для системного языка.

6. Резюме для собеседования (Cheat Sheet)

Вопрос	Ответ
Тип `i`	`int` (Byte Offset)
Значение `i`	Индекс байта в строке, где начинается текущая руна.
Шаг `i`	`1` для ASCII, `2` для кириллицы/европы, `3` для CJK, `4` для эмодзи (BMP+).
`i` == `len(s)`?	Никогда внутри цикла. После цикла `i` равен оффсету последней руны.
Как получить номер руны (0, 1, 2...)	`idx := 0; for _, r := range s { ... idx++ }`
Можно ли делать `s[i]`?	Да, но это даст байт, а не руну. Для руны: `rune(s[i])` работает только если руна 1 байт (ASCII).
Зачем это нужно?	Чтобы `s[i:]` и `s[:i]` работали корректно и за O(1) без повторного декодирования.

Ключевая фраза: > «В for range по строке индекс — это byte offset (смещение в байтах). Это позволяет делать O(1) срезание подстрок s[i:] прямо в цикле, не тратя CPU на пересчет индексов рун в байты. Если нужен порядковый номер руны — заводим отдельную переменную-счетчик».

Вопрос 10. Как эффективно склеить много строк (например, 100) в одну?

Таймкод: <YouTubeSeekTo id="vo1kWaEGzt4" time="00:08:23"/>

Ответ собеседника: Правильный. Использовать strings.Builder. Он накапливает фрагменты во внутреннем буфере и выделяет память один раз при вызове String(). Сложность O(n) вместо O(n²) при конкатенации через +.

Правильный ответ:

1. Золотой стандарт: `strings.Builder` (Go 1.10+)

Это единственный рекомендуемый способ для высокопроизводительной сборки строк в горячих путях.

func BuildString(parts []string) string {
    var b strings.Builder
    
    // 1. Опционально: предварительное резервирование (убирает реаллокации)
    // Если знаете приблизительный размер — дайте подсказку аллокатору.
    totalLen := 0
    for _, p := range parts {
        totalLen += len(p)
    }
    b.Grow(totalLen) // Амортизированная O(1) запись без копирований
    
    // 2. Запись фрагментов
    for _, p := range parts {
        b.WriteString(p) // Внутренне: copy(b.buf[len:], p) + расширение при необходимости
    }
    
    // 3. Zero-copy конвертация в string
    return b.String() // unsafe cast []byte -> string, БЕЗ КОПИРОВАНИЯ
}

Почему это O(N) и быстро:

Экспоненциальный рост буфера: Внутренний []byte растет по стратегии 2x (как слайсы). Суммарное копирование при росте дает амортизированную O(1) запись.
Grow(n) — контроль аллокаций: Если известен итоговый размер — одна аллокация на всю жизнь билдера.
String() — Zero Copy: Метод делает unsafe.Pointer каст внутреннего байтового слайса в string. Данные не копируются второй раз.
- Безопасность: После вызова String() билдер становится «грязным» — дальнейшие записи вызовут копирование данных (Copy-on-Write), чтобы не мутировать уже отданную строку.

2. Альтернатива: `bytes.Buffer` (Legacy / IO)

var buf bytes.Buffer
buf.Grow(totalLen)
buf.WriteString("part1")
// ...
return buf.String() // Тоже zero-copy с Go 1.12+

Разница с strings.Builder:

Особенность	`strings.Builder`	`bytes.Buffer`
Назначение	Сборка строк	Универсальный `io.Reader/Writer`
API	Специализированный (`WriteString`, `WriteByte`, `WriteRune`)	Реализует `io.Writer` (`Write([]byte)`)
Производительность	Чуть быстрее (нет интерфейсов, меньше методов)	Небольшой оверхед на интерфейсы/локи (в старых версиях)
Zero-copy `String()`	Да (гарантированно)	Да (с Go 1.12)
Рекомендация	Дефолт для строк	Когда нужен `io.Writer` (HTTP body, файлы, компрессия)

3. Антипаттерны и почему они плохи

А. Конкатенация через `+` в цикле — O(N²) Квадратичная сложность

s := ""
for i := 0; i < 100; i++ {
    s += parts[i] // КАЖДАЯ итерация: аллокация новой строки + копирование старой + копирование новой части
}

N=100 — незаметно.
N=10,000 — секунды/минуты, давление на GC, фрагментация кучи.

Б. `fmt.Sprintf` / `fmt.Fprintf` в цикле

s := ""
for _, p := range parts {
    s = fmt.Sprintf("%s%s", s, p) // Аллокация форматтера, парсинг формата, аллокация строки
}

Очень медленно: Парсинг формат-строки, рефлексия/интерфейсы, множественные аллокации.

В. `strings.Join` — Хорошо для слайсов, но требует готовый `[]string`

s := strings.Join(parts, "") // O(N) - одна аллокация, одно копирование

Плюсы: Чисто, идиоматично, одна аллокация.
Минусы: Нужно сначала собрать все части в слайс []string. Если части генерируются на лету (стриминг) — не подходит без промежуточного слайса.

4. Продвинутые трюки (Senior Level)

А. `Grow` с точным расчетом размера (избегаем `len()` в цикле)

Если части генерируются динамически, но вы знаете верхнюю границу:

func Generate() string {
    var b strings.Builder
    b.Grow(1024) // Верхняя граница
    for i := 0; i < 100; i++ {
        b.WriteString(computePart(i))
    }
    return b.String()
}

Б. Запись чисел без аллокаций `fmt` (`strconv` + `Builder`)

var b strings.Builder
b.Grow(20)
for i := 0; i < 100; i++ {
    // Плохо: b.WriteString(fmt.Sprintf("%d", i)) -> аллокация строки числа
    // Хорошо:
    b.WriteString(strconv.Itoa(i)) // strconv пишет в буфер без лишних аллокаций (или использует внутренний кэш)
}

В. `WriteByte` / `WriteRune` для одиночных символов

b.WriteByte(',')      // Быстрее WriteString(",")
b.WriteRune('😀')     // Кодирует руну в UTF-8 прямо в буфер

Г. `unsafe` конвертация `[]byte` -> `string` без копирования (если вы владеете слайсом)

Если у вас уже есть []byte и вы гарантируете, что больше не будете его менять:

func BytesToStringNoCopy(b []byte) string {
    return unsafe.String(&b[0], len(b)) // Go 1.20+
    // или старый способ:
    // return *(*string)(unsafe.Pointer(&b))
}

Используется внутри strings.Builder.String(). Вручную — только если вы пишете свой билдер или работаете с mmap/CGO.

5. Бенчмарк (ментальный чек-лист)

Метод	Аллокаций (N=100)	Память	CPU	Вердикт
`s += ...`	~5000 (N²/2)	Огромная	Очень медленно	Не использовать в циклах
`fmt.Sprintf`	~300+	Большая	Медленно	Не использовать в циклах
`strings.Join`	1 (на результат) + 1 (на слайс)	Минимальная	Быстро	Идеально для готового `[]string`
`bytes.Buffer`	~log N (рост)	Низкая	Быстро	OK, если нужен `io.Writer`
`strings.Builder`	~log N (или 1 с `Grow`)	Минимальная	Самый быстрый	DEFAULT CHOICE

6. Резюме для собеседования (Cheat Sheet)

Вопрос: «Склеить 100 строк в цикле?» Ответ: strings.Builder.

Детализация:

Создаем var b strings.Builder.
(Опционально) b.Grow(estimatedSize) — убирает реаллокации.
В цикле b.WriteString(part) / b.WriteByte / b.WriteRune.
Возвращаем b.String() — zero-copy каст []byte -> string.

Почему не +: O(N²) аллокаций и копирований, убивает GC. Почему не bytes.Buffer: Builder специализирован на строках, быстрее, API чище, гарантированный zero-copy. Почему не strings.Join: Требует материализации слайса []string заранее (лишняя память/аллокация слайса), не подходит для стриминга.

Ключевая фраза: > «strings.Builder — это стандарт де-факто для сборки строк. Он дает амортизированную O(1) запись за счет экспоненциального роста буфера и zero-copy конвертацию в строку через unsafe в методе String(). Всегда используйте Grow(n), если знаете примерный размер — это снижает аллокации до одной».

Вопрос 11. В чем заключается шестая ловушка: можно ли напрямую передавать `[]rune` в функцию, ожидающую `string`, и как правильно выполнить конвертацию?

Таймкод: <YouTubeSeekTo id="vo1kWaEGzt4" time="00:09:36"/>

Ответ собеседника: Правильный. Строка (string) и срез рун ([]rune) — это разные типы, их нельзя передавать друг другу без явного приведения типов. Конвертация в обе стороны (string -> []rune и []rune -> string) выполняет полное копирование данных. Для исправления ошибки типа нужно явно привести срез рун к строке: string(runeSlice).

Правильный ответ:

1. Фундаментальное правило: Разные типы — разные представления в памяти

var s string = "Привет"     // StringHeader: {Data: 0x..., Len: 12} (байты UTF-8)
var r []rune = []rune(s)    // SliceHeader:  {Data: 0x..., Len: 6, Cap: 6} (int32 значения)

Характеристика	`string`	`[]rune` (`[]int32`)
Тип	Примитивный (builtin), иммутабельный	Ссылочный (заголовок слайса + куча)
Память	Непрерывный массив байт (UTF-8)	Непрерывный массив int32 (Code Points)
Размер элемента	1 байт	4 байта
Длина (`len`)	Кол-во байт	Кол-во рун (Code Points)
Мутабельность	Нет (Read-only)	Да (можно менять элементы)

Прямое присваивание или передача в функцию НЕВОЗМОЖНО:

func Process(s string) {}

func main() {
    runes := []rune("test")
    Process(runes)        // ОШИБКА КОМПИЛЯЦИИ: cannot use runes (type []rune) as type string
    Process(string(runes)) // OK: явное приведение типа (конвертация)
}

2. Механика конвертации: Всегда копирование (O(N))

В Go нет неявного приведения между string и []rune. Любая конвертация — это выделение новой памяти и копирование данных с декодированием/кодированием UTF-8.

А. `string -> []rune` (Декодирование UTF-8)

runes := []rune(s)
// 1. Аллоцирует []int32 длиной utf8.RuneCountInString(s)
// 2. Проходит по байтам s, декодирует каждую руну (utf8.DecodeRune)
// 3. Записывает int32 в новый слайс

Сложность: O(N) по байтам строки.
Аллокация: Новый слайс в куче ([]int32).

Б. `[]rune -> string` (Кодирование в UTF-8)

s := string(runes)
// 1. Вычисляет необходимый размер буфера (проход по рунам, сумма utf8.RuneLen)
// 2. Аллоцирует байтовый массив (обычно в куче, для строки)
// 3. Проходит по рунам, кодирует каждую в UTF-8 (utf8.EncodeRune)
// 4. Создает StringHeader на получившемся массиве

Сложность: O(N) по рунам.
Аллокация: Новый байтовый массив для строки.
Валидация: Невалидные руны (суррогаты U+D800..U+DFFF, > U+10FFFF) заменяются на RuneError (\uFFFD ).

3. Ловушка производительности: Скрытые O(N²) в циклах

Антипаттерн: Мутация строки через []rune в цикле

// ОЧЕНЬ ПЛОХО: O(N²) аллокаций и копирований
s := "начало"
for i := 0; i < 1000; i++ {
    runes := []rune(s)      // 1. Копирование string -> []rune (аллокация + O(N))
    runes[0] = 'К'          // 2. Мутация
    s = string(runes)       // 3. Копирование []rune -> string (аллокация + O(N))
}

Правильный паттерн: Один раз в []rune, мутируем, один раз в string

// ХОРОШО: O(N) аллокаций суммарно
runes := []rune(s)          // 1 раз: декодирование
for i := 0; i < 1000; i++ {
    runes[0] = 'К'          // Мутация in-place
}
s = string(runes)           // 1 раз: кодирование

Или используйте strings.Builder / bytes.Buffer для сборки (если логика позволяет), избегая []rune вообще.

4. Когда реально нужен `[]rune`?

Случайный доступ по индексу руны (runes[i] за O(1)).
- Парсеры, лексические анализаторы, работа с курсором.
In-place модификация рун (замена, удаление, вставка в середину).
- Алгоритмы вроде переворота строки по рунам: for i, j := 0, len(r)-1; i < j; i, j = i+1, j-1 { r[i], r[j] = r[j], r[i] }.
Взаимодействие с API, требующим []rune (редко).

Когда []rune НЕ нужен:

Просто подсчет рун: utf8.RuneCountInString(s) (нет аллокации).
Итерация: for _, r := range s (нет аллокации).
Поиск подстроки: strings.Index, strings.Contains (работают с байтами/строками).
Сборка строки: strings.Builder.

5. Альтернативы для конкретных задач (Senior Toolkit)

Задача	Инструмент	Почему лучше `[]rune`
Подсчет рун	`utf8.RuneCountInString(s)`	O(N) время, 0 аллокаций.
Итерация	`for _, r := range s`	0 аллокаций, ленивое декодирование.
Поиск руны/подстроки	`strings.IndexRune(s, r)`, `strings.Contains`	Оптимизированные алгоритмы (Boyer-Moore и т.д.) на байтах.
Замена подстроки	`strings.Replace`, `strings.Builder`	Работают на уровне байт/строк, быстрее, меньше GC.
Нормализация (NFC/NFD)	`golang.org/x/text/unicode/norm`	Правильная работа с графемами, не просто рунами.
Сегментация на графемы	`github.com/rivo/uniseg`	`[]rune` ломает эмодзи/флаги/диакритику. `uniseg` — правильно.

6. Резюме для собеседования (Cheat Sheet)

Типы несовместимы: string и []rune — разные типы, компилятор запретит неявное присваивание.
Конвертация = Копирование + Транскодинг: string(runes) и []rune(str) всегда аллоцируют память и проходят по всем данным (O(N)).
Правило «Один раз»: Если нужны мутации рун — конвертируйте один раз в []rune, работайте со слайсом, конвертируйте один раз обратно в string.
Не используйте []rune «на всякий случай»: 90% задач решаются for range, strings, utf8 пакетами без аллокаций.
Графемы ≠ Руны: []rune режет составные символы (флаги, эмодзи с ZWJ, диакритику). Для UI/текстового редактора нужны графемы (uniseg), а не руны.

Ключевая фраза: > «Конвертация string <-> []rune — это дорогая операция (аллокация + полный проход UTF-8 encode/decode). В Go это делается явно через приведение типов string(runes) / []rune(s). В хот-коде мы избегаем лишних конвертаций, используя for range для чтения и strings.Builder для записи, опускаясь до []rune только когда нужен случайный доступ или in-place мутация кодпоинтов».

Вопрос 12. Что возвращает обращение к строке по индексу `s[i]` и почему сравнение `s[0] == 'П'` для строки `"привет"` вызовет ошибку компиляции?

Таймкод: <YouTubeSeekTo id="vo1kWaEGzt4" time="00:11:34"/>

Ответ собеседника: Правильный. Обращение по индексу возвращает байт (uint8), а не руну. Для многобайтовых символов (как 'П' — 2 байта) s[0] вернет только первый байт (208). Сравнение байта с руной ('П') вызовет ошибку компиляции (mismatched types byte и rune). Решение: преобразовать строку в []rune или использовать цикл for range для получения рун.

Правильный ответ:

1. Что возвращает `s[i]`: Тип `byte` (alias `uint8`)

s := "Привет"
b := s[0]        // Тип: byte (uint8)
fmt.Printf("%T %d 0x%X\n", b, b, b) 
// Вывод: uint8 208 0xD0

Почему так: Строка в Go — это иммутабельная обертка над []byte (UTF-8 кодовые единицы). Оператор индексации s[i] выполняет прямую адресную арифметику над базовым массивом байт: *(s.Data + i). Это операция O(1) без декодирования UTF-8.

2. Разбор ошибки компиляции: `s[0] == 'П'`

s := "Привет"
// s[0]     -> byte (uint8)   = 0xD0 (208)
// 'П'      -> rune (int32)   = 0x041F (1055) — Unicode Code Point U+041F

if s[0] == 'П' { } // ОШИБКА КОМПИЛЯЦИИ: invalid operation: s[0] == 'П' (mismatched types byte and rune)

Причина: Go — строго типизированный язык. Неявного приведения между числовыми типами (uint8 vs int32) нет.

s[0] — это первый байт UTF-8 последовательности (0xD0 для 'П').
'П' — это целое число (rune), представляющее кодовую точку Unicode (U+041F).

Это не просто «сравнение не того значения», это ошибка типов на этапе компиляции. Программа не соберется.

3. Визуализация UTF-8 для 'П' (Кириллица, 2 байта)

Концепция	Значение	Go тип	Бинарное представление
Символ (Графема)	`П`	—	—
Code Point (Руна)	`U+041F` (1055)	`rune` (`int32`)	`0000 0100 0001 1111`
UTF-8 Байты	`0xD0 0x9F`	`byte` (`uint8`)	`1101 0000` `1001 1111`
`s[0]`	`0xD0` (208)	`byte`	`1101 0000`
`s[1]`	`0x9F` (159)	`byte`	`1001 1111`

> Вывод: s[0] — это не «первая буква», это «первый байт кодировки первой буквы».

4. Как правильно сравнить первый символ?

Способ А: `for range` (Идиоматичный, ленивый, без аллокаций)

func FirstRuneMatch(s string, target rune) bool {
    for _, r := range s { // r — это rune (int32)
        return r == target // Сравниваем руну с руной — OK
    }
    return false
}

Способ Б: `utf8.DecodeRuneInString` (Ручное декодирование, O(1) для первого)

import "unicode/utf8"

func FirstRuneMatchManual(s string, target rune) bool {
    if len(s) == 0 { return false }
    r, _ := utf8.DecodeRuneInString(s) // Декодирует первую руну
    return r == target
}

Способ В: Конвертация в `[]rune` (Если нужен случайный доступ)

runes := []rune(s) // Аллокация + полное декодирование O(N)
if runes[0] == 'П' { // runes[0] — это rune, сравнение с 'П' (rune) — OK
    // ...
}

5. Типичные ловушки (Edge Cases)

А. Невалидный UTF-8

s := "\xFF\xFE" // Невалидные байты
b := s[0]       // byte = 0xFF (нет ошибки, просто байт)
r, size := utf8.DecodeRuneInString(s) 
// r = utf8.RuneError (U+FFFD ), size = 1

for range и DecodeRuneInString не паникуют, а возвращают RuneError и потребляют 1 байт.

Б. Пустая строка

s := ""
// s[0] -> ПАНИКА: index out of range [0] with length 0
// for range -> просто не войдет в тело цикла (безопасно)
// utf8.DecodeRuneInString -> вернет (RuneError, 0) (безопасно)

Всегда проверяйте len(s) > 0 перед s[0].

В. ASCII-оптимизация (Fast Path)

func IsASCIILetter(b byte) bool {
    return 'A' <= b && b <= 'Z' || 'a' <= b && b <= 'z' // Работает с byte!
}

Если вы гарантированно работаете с ASCII (например, парсинг HTTP заголовков, JSON токенов, CSV), работайте с []byte/byte напрямую — это в 10-100 раз быстрее декодирования рун.

6. Сравнение подходов (Performance Cheat Sheet)

Операция	Сложность	Аллокации	Use Case
`s[i]`	O(1)	Нет	Парсинг бинарных протоколов, ASCII, проверка префиксов байт.
`for _, r := range s`	O(N) байт	Нет	Итерация по всем рунам (стандарт).
`utf8.DecodeRuneInString(s)`	O(1) (макс 4 байта)	Нет	Получить первую руну, проверить валидность.
`[]rune(s)`	O(N) байт	Да (`[]int32`)	Нужен случайный доступ `runes[i]`, мутация, сортировка рун.
`string(runes)`	O(N) рун	Да (байты)	Обратная конвертация после мутаций.

7. Резюме для собеседования (Key Takeaways)

s[i] возвращает byte (uint8), а не символ/руну. Это прямой доступ к байту UTF-8.
Сравнение byte с rune — ошибка компиляции (mismatched types uint8 vs int32). Go не делает неявных конвертаций.
Для кириллицы/не-ASCII s[0] — это только первый байт кодовой точки (для 'П' это 0xD0).
Правильные способы получить руну:
- for range s — для итерации (zero alloc).
- utf8.DecodeRuneInString(s) — для доступа к первой/конкретной руне по байтовому оффсету.
- []rune(s) — только если нужен случайный доступ по индексу руны или мутация (стоит аллокации).
Безопасность: s[0] паникует на пустой строке. for range и utf8.DecodeRuneInString — безопасны.

Ключевая фраза: > «В Go строка — это read-only slice of bytes. Индексация s[i] дает байт, а не руну. Сравнить байт с руной-литералом ('П') нельзя — разные типы (uint8 vs int32). Для работы с символами (кодовыми точками) используйте for range (итерация) или utf8.DecodeRuneInString (точечный доступ), а []rune — только когда нужен случайный доступ или мутация».

Вопрос 1. Что представляет собой строка в Go и как она реализована?​

Вопрос 2. Что такое руна (rune) в Go и чему она соответствует?​

Вопрос 3. Что возвращает функция len() при вызове от строки, содержащей не-ASCII символы?​

Вопрос 4. Как получить количество символов (рун) в строке?​

Вопрос 5. Что возвращается при обращении к строке по индексу s[i]?​

1. Фундаментальное правило​

2. Почему так сделано? (Архитектура строки)​

3. Последствия для не-ASCII (UTF-8)​

Кириллица (2 байта на руну)​

Иероглифы / Базовые эмодзи (3-4 байта)​

Сложные эмодзи (Последовательности)​

4. Типичные ошибки (Anti-patterns)​

А. Сравнение с руной/символом​

Б. Срезание строки s[i:j] по индексам рун​

В. Итерация по байтам вместо рун​

5. Как правильно получить i-ю руну (Code Point)​

Вариант А: for range (Идиоматично, O(N) для прохода до i)​

Вариант Б: utf8.DecodeRuneInString (Ручное декодирование, O(N) для поиска индекса)​

Вариант В: Конвертация в []rune (O(N) память + время, но O(1) доступ)​

6. Как получить i-й байт (если это действительно нужно)​

7. Резюме для собеседования (Cheat Sheet)​

Вопрос 6. Как работает цикл for range по строке?​

1. Сигнатура и семантика​

2. Внутренняя реализация (Псевдокод компилятора)​

3. Поведение на невалидном UTF-8​

4. Паттерны использования и ловушки​

А. Игнорирование индекса (частый кейс)​

Б. Ручной контроль индекса (например, парсинг с возвратом назад)​

В. Ловушка: Модификация строки внутри цикла​

Г. Ловушка: range по []byte vs string​

5. Производительность и оптимизации​

6. Когда for range НЕ подходит​

7. Резюме для собеседования (Cheat Sheet)​

Вопрос 7. Являются ли строки в Go изменяемыми (mutable)?​

1. Официальный ответ: Нет, строки неизменяемы (Immutable)​

2. Что на практике означает «Immutable»?​

3. Почему так сделано? (Design Rationale)​

4. Как «изменить» строку? (Паттерны)​

А. Конкатенация (для единичных случаев)​

Б. strings.Builder (Стандарт для сборки, High Performance)​

В. bytes.Buffer (Устаревший, но еще встречается)​

Г. Конвертация в []byte для мутации (если нужно изменить «по месту»)​

5. Опасные трюки через unsafe (Только для понимания, НЕ В ПРОДЕ)​

6. Сравнение с другими языками​

7. Резюме для собеседования (Cheat Sheet)​

Вопрос 8. Если преобразовать строку в []byte, изменить слайс и преобразовать обратно, изменится ли исходная строка?​

1. Короткий ответ: Нет, исходная строка не изменится.​

2. Что происходит под капотом (Runtime Mechanics)​

string -> []byte (runtime.stringtoslicebyte)​

[]byte -> string (runtime.slicebytetostring)​

3. Почему так сделано? (Инварианты языка)​

4. Исключения и оптимизации (Advanced / Senior Level)​

А. Компиляторные оптимизации (Escape Analysis / SSA)​

Б. strings.Builder — Официальный Zero-Copy Path​

В. unsafe Хак (ОПАСНО, НЕ ДЛЯ ПРОДА)​

5. Производительность: Бенчмарк мысленный​

6. Паттерн «Copy-on-Write» вручную (если очень нужно)​

7. Резюме для собеседования (Cheat Sheet)​

Вопрос 9. Что представляет собой индекс (первая переменная) в цикле for range по строке?​

1. Суть: Это Byte Offset (Смещение в байтах)​

2. Почему так сделано? (Design Rationale)​

3. Ловушки и Best Practices​

А. Не используйте i для доступа к руне по индексу​

Б. Срезание строки внутри цикла — Только через i​

В. Итерация только по рунам (индекс не нужен) — используйте _​

Г. Ручной декодинг (аналог range под капотом)​

4. Сложные кейсы: Составные символы (Grapheme Clusters)​

5. Сравнение с другими языками (для контекста Senior)​

6. Резюме для собеседования (Cheat Sheet)​

Вопрос 10. Как эффективно склеить много строк (например, 100) в одну?​

1. Золотой стандарт: strings.Builder (Go 1.10+)​

Почему это O(N) и быстро:​

2. Альтернатива: bytes.Buffer (Legacy / IO)​

3. Антипаттерны и почему они плохи​

А. Конкатенация через + в цикле — O(N²) Квадратичная сложность​

Б. fmt.Sprintf / fmt.Fprintf в цикле​

В. strings.Join — Хорошо для слайсов, но требует готовый []string​

4. Продвинутые трюки (Senior Level)​

А. Grow с точным расчетом размера (избегаем len() в цикле)​

Б. Запись чисел без аллокаций fmt (strconv + Builder)​

Вопрос 1. Что представляет собой строка в Go и как она реализована?

Вопрос 2. Что такое руна (rune) в Go и чему она соответствует?

Вопрос 3. Что возвращает функция len() при вызове от строки, содержащей не-ASCII символы?

Вопрос 4. Как получить количество символов (рун) в строке?

Вопрос 5. Что возвращается при обращении к строке по индексу `s[i]`?

1. Фундаментальное правило

2. Почему так сделано? (Архитектура строки)

3. Последствия для не-ASCII (UTF-8)

Кириллица (2 байта на руну)

Иероглифы / Базовые эмодзи (3-4 байта)

Сложные эмодзи (Последовательности)

4. Типичные ошибки (Anti-patterns)

А. Сравнение с руной/символом

Б. Срезание строки `s[i:j]` по индексам рун

В. Итерация по байтам вместо рун

5. Как правильно получить i-ю руну (Code Point)

Вариант А: `for range` (Идиоматично, O(N) для прохода до i)

Вариант Б: `utf8.DecodeRuneInString` (Ручное декодирование, O(N) для поиска индекса)

Вариант В: Конвертация в `[]rune` (O(N) память + время, но O(1) доступ)

6. Как получить i-й байт (если это действительно нужно)

7. Резюме для собеседования (Cheat Sheet)

Вопрос 6. Как работает цикл `for range` по строке?

1. Сигнатура и семантика

2. Внутренняя реализация (Псевдокод компилятора)

3. Поведение на невалидном UTF-8

4. Паттерны использования и ловушки

А. Игнорирование индекса (частый кейс)

Б. Ручной контроль индекса (например, парсинг с возвратом назад)

В. Ловушка: Модификация строки внутри цикла

Г. Ловушка: `range` по `[]byte` vs `string`

5. Производительность и оптимизации

6. Когда `for range` НЕ подходит

7. Резюме для собеседования (Cheat Sheet)

Вопрос 7. Являются ли строки в Go изменяемыми (mutable)?

1. Официальный ответ: Нет, строки неизменяемы (Immutable)

2. Что на практике означает «Immutable»?

3. Почему так сделано? (Design Rationale)

4. Как «изменить» строку? (Паттерны)

А. Конкатенация (для единичных случаев)

Б. `strings.Builder` (Стандарт для сборки, High Performance)

В. `bytes.Buffer` (Устаревший, но еще встречается)

Г. Конвертация в `[]byte` для мутации (если нужно изменить «по месту»)

5. Опасные трюки через `unsafe` (Только для понимания, НЕ В ПРОДЕ)

6. Сравнение с другими языками

7. Резюме для собеседования (Cheat Sheet)

Вопрос 8. Если преобразовать строку в `[]byte`, изменить слайс и преобразовать обратно, изменится ли исходная строка?

1. Короткий ответ: Нет, исходная строка не изменится.

2. Что происходит под капотом (Runtime Mechanics)

`string -> []byte` (runtime.stringtoslicebyte)

`[]byte -> string` (runtime.slicebytetostring)

3. Почему так сделано? (Инварианты языка)

4. Исключения и оптимизации (Advanced / Senior Level)

А. Компиляторные оптимизации (Escape Analysis / SSA)

Б. `strings.Builder` — Официальный Zero-Copy Path

В. `unsafe` Хак (ОПАСНО, НЕ ДЛЯ ПРОДА)

5. Производительность: Бенчмарк мысленный

6. Паттерн «Copy-on-Write» вручную (если очень нужно)

7. Резюме для собеседования (Cheat Sheet)

Вопрос 9. Что представляет собой индекс (первая переменная) в цикле `for range` по строке?

1. Суть: Это Byte Offset (Смещение в байтах)

2. Почему так сделано? (Design Rationale)

3. Ловушки и Best Practices

А. Не используйте `i` для доступа к руне по индексу

Б. Срезание строки внутри цикла — Только через `i`

В. Итерация только по рунам (индекс не нужен) — используйте `_`

Г. Ручной декодинг (аналог `range` под капотом)

4. Сложные кейсы: Составные символы (Grapheme Clusters)

5. Сравнение с другими языками (для контекста Senior)

6. Резюме для собеседования (Cheat Sheet)

Вопрос 10. Как эффективно склеить много строк (например, 100) в одну?

1. Золотой стандарт: `strings.Builder` (Go 1.10+)

Почему это O(N) и быстро:

2. Альтернатива: `bytes.Buffer` (Legacy / IO)

3. Антипаттерны и почему они плохи

А. Конкатенация через `+` в цикле — O(N²) Квадратичная сложность

Б. `fmt.Sprintf` / `fmt.Fprintf` в цикле

В. `strings.Join` — Хорошо для слайсов, но требует готовый `[]string`

4. Продвинутые трюки (Senior Level)

А. `Grow` с точным расчетом размера (избегаем `len()` в цикле)

Б. Запись чисел без аллокаций `fmt` (`strconv` + `Builder`)