❓ Где чаще всего хранится значение Go без указателя, объявленное как локальная переменная

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

Это возможно потому, что компилятор заранее знает время жизни переменной: она живёт ровно столько, сколько выполняется функция. Никакой внешней системы управления памятью для этого не нужно.

🐸 Библиотека Go для собеса

❓ Почему выделение памяти на стеке эффективнее, чем на куче

Компилятор способен заранее определить, когда стековая память может быть освобождена, и встраивает инструкции очистки прямо в машинный код. Никакого дополнительного отслеживания во время выполнения не требуется.

В случае кучи ни компилятор, ни среда выполнения не могут точно предсказать, когда память станет ненужной, поэтому нужен сборщик мусора, который регулярно сканирует кучу и освобождает объекты. Это дороже и создаёт паузы.

🐸 Библиотека Go для собеса

❓ Что делает OnceValue и зачем он нужен

OnceValue принимает функцию и возвращает обёртку, которая гарантирует вызов этой функции ровно один раз, сколько бы раз ни вызвали обёртку.

Результат кэшируется и возвращается при всех последующих вызовах. Используется для ленивой и дорогостоящей инициализации.

🐸 Библиотека Go для собеса

❓ Что произойдёт с памятью, которую держит OnceValue, если обёртка больше не используется

Обёртка это замыкание, которое держит ссылки на once, result и f. Пока есть хотя бы одна ссылка на обёртку, GC не освободит эти данные. Если f тяжёлая инициализация, например, загрузка большого файла, а обёртка живёт в глобальной переменной, то данные живут вечно.

🐸 Библиотека Go для собеса

❓ Можно ли вызывать возвращённую функцию в OnceValue конкурентно

Да, это прямо указано в документации: «The returned function may be called concurrently». OnceValue безопасен для использования из нескольких горутин одновременно.

🐸 Библиотека Go для собеса

❓ Объясните, для чего нужен пакет singleflight

Если несколько горутин одновременно требуют одни и те же данные, singleflight гарантирует, что операция будет выполнена лишь один раз, а результат поделится между всеми запросившими его, тем самым снижая избыточную нагрузку и экономя ресурсы.

Пакет предоставляет единственную структуру Group, и основной метод Do(key, fn). Если вызов с таким key уже выполняется, новый вызов блокируется и ждёт. Когда первый завершается, все получают одинаковые value, err и флаг shared, сигнализирующий, что результат был разделён.

var g singleflight.Group

func fetchData(key string) (any, error) {
    v, err, _ := g.Do(key, func() (any, error) {
        return loadFromDB(key) // выполнится только один раз
    })
    return v, err
}

🐸 Библиотека Go для собеса

❓ Что делает io.Seeker

Интерфейс с одним методом Seek(offset int64, whence int) (int64, error).

Устанавливает позицию курсора для следующего Read или Write. Возвращает новое абсолютное смещение от начала файла и ошибку если что-то пошло не так.

Ключевое слово «для следующего». Seek сам ничего не читает и не пишет, он только перемещает внутренний указатель. Следующий вызов Read начнёт именно с этой позиции.

Стандартные типы реализующие Seeker:

os.File — файлы на диске
strings.Reader — строки в памяти
bytes.Reader — байтовые срезы в памяти
io.SectionReader — ограниченный участок другого ReaderAt

🐸 Библиотека Go для собеса

❓ Какой способ для проверки пустой строки лучше: s != "" или len(s) == 0

С точки зрения читаемости, предпочтительнее s != "" — сразу очевидно, что s является строкой. len(s) == 0 более универсальный подход, подходящий для слайсов, мап и других типов, поэтому может быть менее выразительным в контексте строк.

С точки зрения производительности разницы практически нет. Строка в Go — это структура с указателем и длиной, и пустая строка "" не создаётся заново при каждом сравнении. Компилятор с высокой вероятностью оптимизирует оба варианта к одной и той же проверке длины.

🐸 Библиотека Go для собеса

❓ Что такое канонизация строк

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

Одна и та же строка может быть представлена по-разному. Классический пример это Unicode. Символ é можно записать:

- как один кодпоинт U+00E9
- как два кодпоинта e + U+0301

Байтово это разные строки. Визуально — одинаковые. Без канонизации == вернёт false.

В стандартной библиотеке есть пакет golang.org/x/text/unicode/norm, который реализует четыре формы нормализации по стандарту Unicode:

import "golang.org/x/text/unicode/norm"

a := "é"       // precomposed
b := "e\u0301" // decomposed

// Без канонизации
fmt.Println(a == b) // false

// С канонизацией
normA := norm.NFC.String(a)
normB := norm.NFC.String(b)
fmt.Println(normA == normB) // true

Где это важно на практике

- Сравнение имён пользователей и email
- Работа с файловой системой (macOS использует NFD, Linux — NFC)
- Поиск по тексту
- Безопасность: канонизация помогает избежать обходов валидации через визуально идентичные, но байтово разные строки

🐸 Библиотека Go для собеса

❓ Что делает io.WriterTo и как он связан с io.Copy

Интерфейс:

type WriterTo interface {
    WriteTo(w io.Writer) (n int64, err error)
}

Суть: тип сам берёт управление на себя и решает, как именно записать свои данные в переданный Writer.

Зачем это нужно

io.Copy по умолчанию работает через буфер 32KB и читает кусок из источника, пишет в назначение, и так по кругу. Данные гоняются через userspace.

Но некоторые типы знают более эффективный путь. Например, *os.File на Linux может использовать системный вызов sendfile и данные перемещаются на уровне ядра, без копирования в память процесса.

Как io.Copy это использует

Перед тем как запустить свой буферный цикл, она проверяет интерфейсы:

// 1. Источник умеет писать сам?
if wt, ok := src.(WriterTo); ok {
    return wt.WriteTo(dst)
}
// 2. Назначение умеет читать само?
if rf, ok := dst.(ReaderFrom); ok {
    return rf.ReadFrom(src)
}
// 3. Fallback — буфер 32KB

Если источник реализует WriterTo, то io.Copy просто уступает ему управление.

🐸 Библиотека Go для собеса

❓ Как корректно прокинуть context.Context в функцию внутри OnceValue

Напрямую никак: OnceValue принимает функцию без аргументов.

Контекст нужно захватить в замыкании. Но это опасно, контекст может быть отменён к моменту первого вызова:

// Плохо: ctx может быть уже отменён
ctx := context.Background()
get := sync.OnceValue(func() *DB {
    return connect(ctx) // ctx захвачен в замыкании
})

🐸 Библиотека Go для собеса

❓ Как отменить множество горутин одновременно

Когда горутин много, останавливать каждую вручную не получится. Нужен способ послать сигнал сразу всем:

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()

    for i := 0; i < 5; i++ {
        go func(id int) {
            for {
                select {
                case <-ctx.Done():
                    fmt.Printf("горутина %d остановлена\n", id)
                    return
                default:
                    fmt.Printf("горутина %d работает\n", id)
                    time.Sleep(500 * time.Millisecond)
                }
            }
        }(i)
    }

    time.Sleep(2 * time.Second)
    cancel()
    time.Sleep(100 * time.Millisecond)
}

context.WithCancel возвращает контекст и функцию cancel. Контекст передаётся во все горутины. Каждая горутина слушает ctx.Done() через select. Когда вызывается cancel(), канал ctx.Done() закрывается, и все горутины, которые его слушают, получают сигнал одновременно. defer cancel() в начале гарантирует, что ресурсы освободятся даже если функция завершится раньше времени.

🐸 Библиотека Go для собеса

❓ Скомпилируется ли код при циклической зависимости

В Go компилятор запрещает циклические зависимости между пакетами. Если пакет A импортирует B, а B импортирует A, то код просто не соберётся.

Go намеренно не даёт собрать такой код по двум причинам. Первая: порядок инициализации. Если A зависит от B, а B от A, непонятно, что инициализировать первым. Вторая это структура кода. Цикл между пакетами почти всегда сигнализирует о проблеме в архитектуре.

Как решить проблему

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

🐸 Библиотека Go для собеса

❓ Почему append на nil-срезе работает, а запись в nil-мапу вызывает панику

nil-срез это валидное значение с len == 0 и cap == 0. Когда вызывается append(), Go сам выделяет новую память под капотом. Явная инициализация не нужна.

var a []int
a = append(a, 4, 5, 6) // Go выделяет память сам
fmt.Println(a)          // [4 5 6]

nil-мапа не инициализирована, у неё нет памяти для хранения данных. Любая попытка записи немедленно вызывает панику в рантайме. Перед использованием нужно явно вызвать make.

var m map[int]int
// m[1] = 1  ← паника!

m = make(map[int]int)
m[1] = 1 // теперь работает

append это функция, которая сама управляет памятью и возвращает новый срез. Мапа же это указатель на структуру данных, и без инициализации этой структуры просто не существует.

🐸 Библиотека Go для собеса

❓ Как работает sync.WaitGroup изнутри

Внутри WaitGroup хранит счётчик. Вы управляете им через три метода:

Add(n) увеличивает счётчик на n. Вызывать его нужно до запуска горутин, а не внутри них — иначе возникает гонка данных: Wait может сработать раньше, чем Add успеет зарегистрировать горутину.

Done() уменьшает счётчик на 1. Его вызывают внутри горутины, когда работа завершена. Чтобы не забыть вызвать его даже при панике, принято писать defer wg.Done() в самом начале горутины.

Wait() блокирует выполнение до тех пор, пока счётчик не вернётся к нулю. Как только все горутины вызвали Done() — основной поток продолжает работу.

🐸 Библиотека Go для собеса

❓ В Go существует несколько способов возврата структур или их частей. Назовите основные.

1. Возврат копии структуры

Функция возвращает значение, изменения копии не затронут оригинал:

func returnCopy() MyStruct {
    return MyStruct{Value: 1}
}

2. Возврат указателя на структуру

Позволяет избежать копирования и работать напрямую с объектом в памяти:

func returnPointer() *MyStruct {
    return &MyStruct{Value: 2}
}

3. Изменение через указатель-параметр

Функция принимает указатель и напрямую изменяет оригинальный объект без возврата:

func modifyStruct(s *MyStruct) {
    s.Value = 3
}

4. Возврат части структуры

Возвращает только нужное поле, а не всю структуру целиком:

func returnValue(s MyStruct) int {
    return s.Value
}

5. Возврат через интерфейс

Позволяет скрыть конкретную реализацию за абстракцией:

type MyInterface interface { DoSomething() }

func returnInterface() MyInterface {
    return MyStruct{}
}

6. Срезы и мапы структур

Возврат набора структур через срез или ассоциативный массив:

func returnSlice() []MyStruct {
    return []MyStruct{{Value: 4}, {Value: 5}}
}

func returnMap() map[string]MyStruct {
    return map[string]MyStruct{
        "first":  {Value: 6},
        "second": {Value: 7},
    }
}

7. Возврат через канал

Передача структуры между горутинами для конкурентных сценариев:

func sendToChannel(ch chan MyStruct) {
    ch <- MyStruct{Value: 8}
}

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

🐸 Библиотека Go для собеса

❓ Что такое паттерн Circuit Breaker и зачем он нужен

Circuit Breaker это защитный паттерн для распределённых систем. Он автоматически «отключает» вызовы к нестабильному сервису, чтобы предотвратить каскадные сбои и снизить нагрузку на и без того падающий узел.

Аналогия проста: как автоматический выключатель в электрощитке защищает проводку от перегрузки, так и Circuit Breaker защищает систему от цепной реакции ошибок.

Два состояния

Замкнуто — штатный режим. Все запросы проходят в обычном режиме. Счётчик ошибок растёт при каждом сбое.

Разомкнуто — защитный режим. После превышения порога ошибок паттерн перестаёт вызывать сервис и сразу возвращает ошибку. Сервис получает время на восстановление.

Реализация:

type Circuit func(context.Context) (string, error)

func Breaker(circuit Circuit, failureThreshold uint) Circuit {
    var consecutiveFailures int = 0
    var lastAttempt = time.Now()
    var m sync.RWMutex

    return func(ctx context.Context) (string, error) {
        m.RLock()
        d := consecutiveFailures - int(failureThreshold)

        if d >= 0 {
            // Экспоненциальная выдержка: 2, 4, 8... секунд
            shouldRetryAt := lastAttempt.Add(time.Second * 2 << d)
            if !time.Now().After(shouldRetryAt) {
                m.RUnlock()
                return "", errors.New("service unreachable")
            }
        }
        m.RUnlock()

        response, err := circuit(ctx)

        m.Lock()
        defer m.Unlock()

        lastAttempt = time.Now()
        if err != nil {
            consecutiveFailures++
            return response, err
        }

        consecutiveFailures = 0 // Успех — сбрасываем счётчик
        return response, nil
    }
}

Что важно в этой реализации

• sync.RWMutex защищает общее состояние при конкурентных вызовах

• Экспоненциальная выдержка (2 << d) даёт сервису всё больше времени на восстановление с каждой неудачной попыткой

• После успешного вызова счётчик сбрасывается — цепь «замыкается» обратно автоматически

• Функция возвращает тот же тип Circuit, что позволяет прозрачно встраивать Breaker без изменения кода клиента

🐸 Библиотека Go для собеса

❓Что такое package aliasing

Package aliasing это возможность присвоить псевдоним импортируемому пакету прямо в блоке import. Полезен в конкретных ситуациях, но злоупотреблять им не стоит: лишние алиасы усложняют чтение кода.

Синтаксис:

import fm "fmt"

fm.Println("hello") // вместо fmt.Println

Алиас указывается перед путём к пакету и полностью заменяет его имя в текущем файле.

🐸 Библиотека Go для собеса

❓ Когда использовать package aliasing

📌 Кейсы использования

1. Конфликт имён

Два пакета с одинаковым именем. Без алиасов код не скомпилируется.

import (
    sqlDB   "project/sql/db"
    nosqlDB "project/nosql/db"
)

2. Длинный путь импорта

Сокращает шум при частом обращении к пакету с громоздким путём:

import (
    mh "myproject/subproject/module/helpers"
)

3. Неудобное или неочевидное имя пакета

Актуально для сгенерированного кода, когда имя пакета не совпадает с тем, что ожидает читатель:

import (
    validator "github.com/myorg/gen/v2/validate_pb"
)

4. Пустой импорт _

Специальный алиас для импорта ради побочных эффектов: регистрация драйвера, init()-функция; без использования пакета в коде:

import _ "github.com/lib/pq" // регистрирует PostgreSQL-драйвер

5. Импорт в текущее пространство имён .

Позволяет обращаться к экспортируемым именам пакета без префикса:

import . "math"
 
r := Sqrt(16) // вместо math.Sqrt(16)

🐸 Библиотека Go для собеса