Справочник GO. Часть I

Чтение отсутствующего ключа возвращает нулевое значение типа, без паники. Идиома «запятая, ok» различает «нет ключа» и «значение равно нулю»:

v, ok := m[key]   // ok == false, если ключа нет

Удаление делается через delete(m, key) — безопасно даже для отсутствующего ключа. Удаление во время range допустимо.

3. Строки

Строка в Go — это неизменяемая (immutable) последовательность байтов. Внутреннее представление — структура из двух полей:

type stringStruct struct {
    str unsafe.Pointer // указатель на байты
    len int            // длина в байтах
}

Строка хранит байты, обычно в кодировке UTF-8, но сам тип string ничего не гарантирует о валидности UTF-8 — это просто байты.

Байты против рун

Важно различать три понятия:

• byte — псевдоним uint8, один байт. len(s) возвращает число байтов, а не символов.
• rune — псевдоним int32, один код-поинт Unicode.
• Индексирование s[i] даёт байт, а не символ.

Один символ Unicode (руна) в UTF-8 кодируется 1–4 байтами. Поэтому для русского текста len("привет") равно 12 (по 2 байта на символ), а не 6.

s := "héllo"
fmt.Println(len(s))            // 6: 'é' занимает 2 байта
for i, r := range s {          // range итерирует по РУНАМ
    fmt.Printf("%d:%c ", i, r) // i — байтовое смещение
}

range по строке декодирует UTF-8 и выдаёт руны вместе с их байтовыми смещениями. Невалидные байты дают RuneError (U+FFFD).

Конвертации

[]byte(s) и string(b) по умолчанию копируют данные, потому что строка неизменяема, а срез — нет. Компилятор оптимизирует ряд частных случаев (например, конвертацию во временном выражении в range или при сравнении), избегая копии.

[]rune(s) декодирует всю строку в срез рун (тоже с аллокацией). string(r) для одной руны кодирует её в UTF-8.

b := []byte("abc")  // копия в изменяемый срез
b[0] = 'X'
s2 := string(b)     // снова копия → "Xbc"

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

Конкатенация + в цикле создаёт новую строку на каждой итерации — O(n²) по памяти. Для построения больших строк используйте strings.Builder, который накапливает байты в растущем буфере без лишних копий:

var b strings.Builder
for i := 0; i < 1000; i++ {
    b.WriteString("x")
}
result := b.String() // одна финальная строка

strings.Builder запрещает копирование себя после использования (проверка через noCopy), чтобы не нарушить инвариант общего буфера.

---

4. Структуры данных (структуры)

Структура (struct) — это составной тип, агрегирующий именованные поля. Структуры — значимые типы: присваивание и передача в функцию копируют все поля.

type User struct {
    ID   int
    Name string
    Age  uint8
}
u := User{ID: 1, Name: "Ann"}
v := u           // полная копия
v.Name = "Bob"   // u.Name остаётся "Ann"

Выравнивание и размер (padding)

Поля размещаются в памяти с учётом выравнивания (alignment): адрес поля должен быть кратен его размеру (8-байтовое поле — по адресу, кратному 8, и т. п.). Компилятор вставляет заполнитель (padding) между полями. Поэтому порядок полей влияет на размер структуры:

type Bad struct {
    a bool   // 1 байт
    b int64  // 8 байт → 7 байт padding перед ним
    c bool   // 1 байт + хвостовой padding
}                 // итого 24 байта

type Good struct {
    b int64  // 8
    a bool   // 1
    c bool   // 1 + 6 padding
}                 // итого 16 байт

Правило оптимизации: размещайте поля от больших к меньшим. Узнать размер можно через unsafe.Sizeof, смещения — через unsafe.Offsetof.

Встраивание (embedding)

Go использует композицию через встраивание вместо наследования. Анонимное поле «поднимает» свои методы и поля во внешнюю структуру:

type Animal struct{ Name string }
func (a Animal) Speak() string { return a.Name + " makes a sound" }

type Dog struct {
    Animal       // встраивание
    Breed string
}
d := Dog{Animal{"Rex"}, "Lab"}
d.Speak()        // продвинутый метод, фактически d.Animal.Speak()
d.Name           // продвинутое поле

Встраивание интерфейса в структуру — частый приём для частичной реализации или обёрток (декораторов).

Пустая структура

struct{} занимает 0 байт. Применяется как «нулевая» нагрузка: множество на map (map[string]struct{}), сигнальный канал (chan struct{}), маркеры. Все значения struct{}{} указывают на один общий адрес zerobase.

Теги, сравнимость

Поля могут нести строковые теги, читаемые через рефлексию (используется JSON, ORM и т. п.): json:"name,omitempty".

Структура сравнима оператором ==, если сравнимы все её поля. Структура со срезом, map или функцией в поле несравнима — её нельзя использовать как ключ map.

5. Интерфейсы

Интерфейс задаёт набор методов (контракт поведения). Тип удовлетворяет интерфейсу неявно — достаточно реализовать все его методы, явного implements не требуется (структурная типизация, «duck typing»).

type Stringer interface {
    String() string
}

Внутреннее устройство

Значение интерфейса — это пара указателей (16 байт на 64-битной системе). Различают две формы:

• eface (interface{} / any) — пустой интерфейс:

type eface struct {
    _type *_type         // дескриптор динамического типа
    data  unsafe.Pointer // указатель на данные (или сами данные)
}

• iface — непустой интерфейс с методами:

type iface struct {
    tab  *itab           // таблица: тип + методы
    data unsafe.Pointer  // указатель на конкретное значение
}

itab (interface table) кэширует информацию о конкретном типе и таблицу указателей на методы, реализующие интерфейс. Вызов метода через интерфейс — это динамическая диспетчеризация: переход по соответствующему указателю в itab. Сами itab кэшируются рантаймом, чтобы не строиться повторно.

Typed nil — главный подвох

Интерфейс равен nil только если оба его поля нулевые (нет ни типа, ни данных). Если положить в интерфейс nil-указатель конкретного типа, интерфейс перестаёт быть nil, потому что поле типа заполнено:

func do() error {
    var p *MyError = nil
    return p          // возвращаем typed nil!
}
err := do()
if err != nil {       // ИСТИНА! err хранит (*MyError, nil)
    // сюда попадём, хотя «ошибки нет»
}

Это классический источник багов. Правило: возвращайте буквально nil, а не nil-указатель, упакованный в интерфейс.

Утверждение и переключение типа

v, ok := i.(string)      // безопасное утверждение типа
switch x := i.(type) {   // type switch
case int:    useInt(x)
case string: useStr(x)
default:     unknown()
}

Утверждение без ok (i.(string)) паникует при несовпадении типа. Пустой интерфейс any способен хранить значение любого типа и широко используется в обобщённом коде (хотя с появлением дженериков в Go 1.18 многие сценарии решаются типобезопасно через параметры типа).

Указатель или значение как приёмник

Если методы определены на указателе (func (t T) M()), то интерфейс удовлетворяет только T, но не T, так как нельзя взять адрес у не-адресуемого значения. Это влияет на то, какой набор методов попадает в itab.

---

6. Деферы (defer)

defer откладывает вызов функции до момента выхода из окружающей функции — при return, при достижении конца тела или при панике. Это идиоматичный способ освобождать ресурсы рядом с местом их захвата:

f, err := os.Open(name)
if err != nil { return err }
defer f.Close()   // выполнится при любом выходе из функции

Семантика

LIFO-порядок. Несколько defer выполняются в порядке, обратном объявлению (как стек):

defer fmt.Print("1")
defer fmt.Print("2")
defer fmt.Print("3")  // напечатает 3 2 1

Аргументы вычисляются сразу. Значения аргументов отложенного вызова фиксируются в момент выполнения defer, а не в момент фактического вызова:

i := 0
defer fmt.Println(i) // напечатает 0, хотя ниже i меняется
i = 10

Чтобы захватить актуальное значение, оборачивайте в замыкание: defer func() { fmt.Println(i) }().

Взаимодействие с именованными возвращаемыми значениями. Отложенная функция может изменить именованный результат, потому что выполняется после присваивания результата, но до фактического возврата:

func inc() (res int) {
    defer func() { res++ }()
    return 5          // вернёт 6
}

Это основной механизм, которым recover оборачивает ошибки в возвращаемое значение.

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

Исторически defer был относительно дорогим (аллокация записи в связном списке деферов). В Go 1.13–1.14 появилась оптимизация open-coded defers: для функций с небольшим, статически известным числом деферов компилятор встраивает их прямо в код выхода, делая стоимость почти нулевой. В горячих циклах с динамическим числом деферов накладные расходы всё ещё заметны, поэтому в особо нагруженных местах иногда освобождают ресурсы вручную.