Вопросы на собеседовании по Go
297 вопросов с реальных собеседований в 28 подтемах. У первых вопросов каждой подтемы — короткий ответ и источник.
Основы языка
13 вопросовКаковы ключевые особенности и сильные стороны языка Go?
Короткий ответ
Go — компилируемый, статически типизированный язык со сборкой мусора, созданный в Google ради простоты и масштабируемой разработки.
Источник: go.dev
Какая типизация используется в Go — статическая или динамическая, и что это означает на практике?
Короткий ответ
Go статически и строго типизирован: тип каждой переменной известен на этапе компиляции и не меняется в рантайме, а несоответствие типов — ошибка компиляции. Неявных преобразований между типизированными значениями нет даже между числовыми типами — нужно явное приведение (исключение — нетипизированные константы:
var f float64 = 1допустимо). При этом есть вывод типов: вx := 42компилятор сам определяет тип по правой части, но переменная всё равно остаётся статически типизированной.Источник: go.dev
Какие числовые типы есть в Go и в чём их особенности?
Короткий ответ
Есть целые со знаком (int8/16/32/64) и без (uint8/16/32/64), а также int/uint, размер которых зависит от платформы (32 или 64 бита), и uintptr. Есть вещественные float32/float64 и комплексные complex64/128, а также псевдонимы byte (= uint8) и rune (= int32). Числовые типы несовместимы без явного преобразования, даже
intиint64. Переполнение беззнаковых определено как арифметика по модулю 2^n; для знаковых результат тоже детерминирован (обёртка в дополнительном коде), паники нет. Граница: переполнение константного выражения — ошибка компиляции, а не обёртка.Источник: go.dev
Чем объявление переменной через var отличается от краткого объявления через := ?
Короткий ответ
var x int = 5(илиvar x int) объявляет переменную на любом уровне, включая пакетный; без инициализатора переменная получает нулевое значение своего типа. Краткое объявлениеx := 5допустимо только внутри функций, тип выводится из выражения.:=требует, чтобы слева была хотя бы одна новая переменная; остальные, уже объявленные в том же блоке, получают присваивание, а не создаются заново (в другом, вложенном блоке:=создаст новую переменную — см. затенение).Источник: go.dev
Типы, значения и указатели
9 вопросовЧто такое нулевое значение (zero value) в Go и каким типам какое значение назначается по умолчанию?
Короткий ответ
Любая переменная, объявленная без инициализатора, получает нулевое значение своего типа:
0для чисел,falseдляbool,""для строк,nilдля указателей, срезов, мап, каналов, функций и интерфейсов.Источник: go.dev
Как в Go передаются аргументы в функции — по значению или по ссылке?
Короткий ответ
В Go аргументы всегда передаются по значению: функция получает копию, передачи по ссылке нет.
Источник: go.dev
Что такое указатель в Go и для чего он нужен?
Короткий ответ
Указатель хранит адрес значения в памяти:
&xберёт адрес,*pразыменовывает.Источник: go.dev
Массивы и слайсы
18 вопросовВ чём разница между массивом и слайсом в Go?
Короткий ответ
Массив имеет фиксированную длину, которая входит в его тип, и копируется целиком; слайс — динамическое «окно» над базовым массивом, и его копия указывает на те же данные.
Источник: go.dev
Как устроен слайс под капотом и из каких полей состоит его заголовок?
Короткий ответ
Слайс — заголовок из трёх полей: указатель на первый элемент базового массива, длина (
len) и ёмкость (cap); сами данные лежат в отдельном массиве.Источник: go.dev
В чём разница между длиной (len) и ёмкостью (cap) слайса и зачем нужна ёмкость?
Короткий ответ
len— сколько элементов сейчас доступно в слайсе,cap— сколько элементов слайс может занять без новой аллокации, то есть сколько места под него выделено в базовом массиве.Источник: go.dev
Как работает append и по какому правилу растёт ёмкость слайса?
Короткий ответ
append дописывает элементы в конец. Если новой длине хватает ёмкости, данные кладутся в существующий базовый массив; если нет, выделяется новый массив большего размера, старые элементы копируются в него, и возвращается новый заголовок слайса. Поэтому результат append нужно присваивать обратно.
Источник: go.dev
Будут ли видны в вызывающей функции элементы, добавленные через append в слайс, переданный по значению?
Короткий ответ
Нет. Функция получает копию заголовка слайса (указатель, len, cap). append внутри функции обновляет её локальный len (и, возможно, указатель при переаллокации), но заголовок вызывающего не меняется — там len прежний, поэтому новые элементы он «не видит». Даже если места хватило и append записал элемент в общий базовый массив, вызывающий не увидит его без переразрезания (
s[:n+1]), так как его len не увеличился.Источник: go.dev
Мапы
14 вопросовКак устроена мапа (хеш-таблица) в Go под капотом?
Короткий ответ
Мапа — хеш-таблица на Swiss Tables (с Go 1.24). Верхнеуровневый Map держит directory таблиц, таблица — массив групп по 8 слотов, у каждой группы 8-байтовое control-слово (слот занят, пуст или удалён плюс 7 бит хеша). Мапа до 8 элементов — одна группа без directory. Переменная-мапа указывает на этот Map, поэтому копия переменной ссылается на ту же таблицу.
Источник: github.com
Какова асимптотическая сложность операций с мапой в среднем и худшем случаях?
Короткий ответ
В среднем поиск, вставка и удаление — амортизированные O(1): хеш сразу приводит к нужной группе, а рост таблицы размазан по операциям. Худший случай — O(n): если все ключи дают одну и ту же последовательность проб и поиск вырождается в перебор.
Источник: github.com
Как в мапе Go разрешаются коллизии хешей?
Короткий ответ
Коллизии разрешаются открытой адресацией: при занятых слотах поиск идёт по группам квадратичным пробированием, пока не найдётся ключ или группа со свободным слотом. Внутри группы из 8 слотов 7-битные H2-метки всех слотов сверяются с хешем одной операцией по control-слову, полное сравнение ключа нужно только при совпадении метки. Удаление из полностью заполненной группы оставляет tombstone, чтобы не оборвать цепочку проб.
Источник: github.com
Гарантируется ли порядок обхода мапы через range и почему он такой?
Короткий ответ
Нет. Спецификация прямо говорит: порядок обхода мапы не определён и не гарантируется одинаковым от прохода к проходу. Более того, рантайм намеренно рандомизирует старт range (случайная точка старта), чтобы никто не полагался на порядок и код не ломался при смене реализации мапы. Если нужен детерминированный порядок — соберите ключи в слайс и отсортируйте (
slices.Sorted(maps.Keys(m)), Go 1.23+), а затем обходите мапу по этому слайсу.Источник: go.dev
Какое значение имеет неинициализированная (nil) мапа и какие операции с ней допустимы, а какие вызовут панику?
Короткий ответ
Мапа, не созданная через
makeили литерал (var m map[string]int), равна nil. С ней можно читать (вернётся нулевое значение), братьlen(0), обходитьrange(ноль итераций) и вызыватьdelete(no-op).Источник: go.dev
Строки, руны и байты
9 вопросовКак устроена строка в Go на уровне внутреннего представления?
Короткий ответ
Строка — это небольшой заголовок из двух полей: указателя на байты и длины в байтах. Сами байты лежат отдельно от заголовка, и менять их через строку нельзя: язык гарантирует неизменяемость. Байты литералов компилятор кладёт в секцию только для чтения, а строки, собранные в рантайме, обычно лежат в куче (короткую строку, которая не покидает функцию, компилятор может разместить на стеке). Строка не хранит завершающий ноль, как в C, — длина известна явно. Байты трактуются как UTF-8, но язык этого не навязывает: строка может содержать произвольные байты. Поскольку заголовок маленький, передача и присваивание строки копируют лишь два слова, а сами байты разделяются — это дёшево именно благодаря неизменяемости.
Источник: go.dev
Что следует из того, что строка в Go неизменяема?
Короткий ответ
Раз байты строки менять нельзя, изменить байт по индексу (
s[0] = 'x') невозможно — это ошибка компиляции. Любое «изменение» строки на деле создаёт новую. Зато из неизменяемости следуют приятные свойства: байты строки можно читать из нескольких горутин без блокировок, потому что их никто не изменит (общую переменную строки, которую переприсваивают, это не защищает), под-строку (s[i:j]) можно делать без копирования — она указывает на те же байты.Источник: go.dev
В чём разница между типами rune и byte?
Короткий ответ
byte— псевдонимuint8, один байт данных;rune— псевдонимint32, один кодпоинт Unicode.Источник: go.dev
Структуры, методы и встраивание
16 вопросовВ чём разница между методом с получателем по значению и по указателю?
Короткий ответ
Метод с получателем по значению работает с копией: изменения полей внутри метода снаружи не видны. Метод с получателем по указателю работает с самим объектом: может его менять и не копирует структуру при вызове.
Источник: go.dev
В каких случаях следует использовать получатель по указателю, а в каких по значению?
Короткий ответ
Получатель-указатель нужен, когда метод должен менять получателя, когда структура большая или когда тип содержит то, что нельзя копировать (например,
sync.Mutex); получатель по значению подходит для небольших неизменяемых типов.Источник: go.dev
Допустимо ли смешивать методы с получателями по значению и по указателю у одного типа?
Короткий ответ
Компилятор смешивание допускает, но так делать не рекомендуется: набор методов значения
Tи набор методов*Tразличаются, и это даёт неочевидные ошибки.Источник: go.dev
Почему вызов метода у nil-указателя не всегда приводит к панике, а обращение к полю приводит?
Короткий ответ
Вызов метода на nil-указателе не паникует сам по себе, потому что получатель передаётся в метод как обычный первый аргумент; паника возникает при разыменовании nil, например при обращении к полю.
Источник: go.dev
Можно ли определять методы для типов, отличных от структур?
Короткий ответ
Да. Метод можно определить на любом именованном (defined) типе, объявленном в том же пакете:
type Celsius float64,type IntSlice []int,type Handler func(w http.ResponseWriter, r *http.Request)— всем им можно дать методы. Это активно используют: например,time.Duration— это int64 с методами, а http.HandlerFunc — функциональный тип с методом ServeHTTP.Источник: go.dev
Интерфейсы
12 вопросовЧто такое интерфейсы в Go и какова их роль?
Короткий ответ
Интерфейс — набор сигнатур методов, описывающий поведение, а не данные; переменная интерфейсного типа может хранить любое значение, у которого есть все эти методы.
Источник: go.dev
Как устроены интерфейсы под капотом (iface и eface)?
Короткий ответ
Интерфейсное значение — это пара из двух слов. Для интерфейса с методами это структура iface: указатель на itab (таблицу, где лежат тип динамического значения и указатели на его методы) и указатель на сами данные. Для пустого интерфейса — eface: указатель на дескриптор типа (\_type) и указатель на данные. Отсюда практические следствия: nil-интерфейс — это когда оба слова нулевые; вызов метода через интерфейс — это косвенный вызов через itab (чуть дороже прямого); а укладка не-указательного значения в интерфейс может потребовать выделения памяти под копию (боксинга): рантайм обходится без него для нулевых и малых неотрицательных целых значений (до 255), а компилятор — для значений, которые не убегают из функции.
Источник: go.dev
Что представляет собой пустой интерфейс (interface{} / any) и для чего он применяется?
Короткий ответ
Пустой интерфейс
interface{}не требует ни одного метода, поэтому ему удовлетворяет любой тип, и переменная такого типа хранит значение чего угодно; с Go 1.18 для него есть псевдонимany.Источник: go.dev
Как компилятор понимает, что тип реализует интерфейс, если наследование неявное?
Короткий ответ
Компилятор проверяет реализацию структурно и статически: если набор методов типа включает все методы интерфейса с точным совпадением сигнатур, тип считается реализующим интерфейс, ключевое слово
implementsне нужно.Источник: go.dev
Дженерики
6 вопросовКак устроены и как работают дженерики (generics) в Go?
Короткий ответ
Дженерики (Go 1.18) позволяют написать функцию или тип один раз для разных типов: параметр типа объявляется в квадратных скобках вместе с ограничением.
Источник: go.dev
Что такое ограничения типов (constraints) и зачем нужен constraint comparable?
Короткий ответ
Ограничение — интерфейс, который задаёт, какие типы можно подставить в параметр типа;
comparableразрешает только типы, для которых определены==и!=.Источник: go.dev
Что такое несравниваемые (uncomparable) типы в Go?
Короткий ответ
Несравнимые типы — те, для которых
==и!=не определены, кроме сравнения сnil: срезы, мапы, функции и любые структуры и массивы, содержащие такие поля.Источник: go.dev
Ошибки, panic и recover
10 вопросовКак в Go принято обрабатывать ошибки и что означает подход «ошибка как значение»?
Короткий ответ
В Go обычные ошибки не бросаются как исключения: функция возвращает значение типа
errorпоследним результатом, а вызывающий проверяет его явно.Источник: go.dev
В чём разница между errors.Is и errors.As?
Короткий ответ
errors.Isпроверяет, есть ли в цепочке (дереве) обёрнутых ошибок конкретное значение, аerrors.Asищет в нём ошибку нужного типа и записывает её в переменную.Источник: pkg.go.dev
Как обернуть ошибку с сохранением контекста и что делает глагол %w в fmt.Errorf?
Короткий ответ
Оборачивают через
fmt.Errorf("read config: %w", err). Глагол %w (появился в Go 1.13) не просто вставляет текст ошибки, а сохраняет исходную ошибку внутри новой, создавая цепочку: к ней потом применимы errors.Unwrap, errors.Is и errors.As. В отличие от %v, который лишь форматирует текст и теряет связь с оригиналом, %w позволяет добавить контекст («что мы делали, когда упало») и при этом сохранить возможность распознать первопричину выше по стеку. С Go 1.20 в одном Errorf можно обернуть несколько ошибок несколькими %w (или errors.Join).Источник: go.dev
defer
7 вопросовЧто такое defer в Go, как он работает и для чего применяется?
Короткий ответ
defer откладывает вызов функции до момента выхода из окружающей функции — при обычном return, при достижении конца тела функции и при панике. Применяют его для парного освобождения ресурсов рядом с их захватом: открыли файл — тут же
defer f.Close(), взяли мьютекс —defer mu.Unlock(). Освобождение срабатывает на каждой ветке выхода: его не нужно дублировать перед каждым return, и оно выполнится даже при панике.Источник: go.dev
В каком порядке выполняются несколько defer, объявленных в одной функции?
Короткий ответ
Несколько
deferв одной функции выполняются в обратном порядке объявления (LIFO): последний объявленный отработает первым.Источник: go.dev
В какой момент вычисляются аргументы отложенного через defer вызова?
Короткий ответ
Аргументы defer вычисляются сразу, в момент выполнения строки defer, а сам вызов откладывается. Поэтому
defer fmt.Println(i)«запомнит» текущее значение i, и если потом i изменится, напечатается старое. Если нужно взять значение именно на момент выхода, оборачивают в анонимную функцию:defer func(){ fmt.Println(i) }()— тут i прочитается позже.Источник: go.dev
Горутины и планировщик
18 вопросовЧто такое горутина и чем она отличается от потока операционной системы?
Короткий ответ
Горутина — лёгкий поток выполнения, которым управляет рантайм Go, а не ядро ОС: множество горутин мультиплексируется на небольшое число потоков ОС (модель M:N).
Источник: go.dev
За счёт чего горутины легковесны, а их создание обходится так дёшево?
Короткий ответ
Три причины. Первая — маленький растущий стек: горутина стартует примерно с 2 КБ и увеличивается по мере надобности копированием на больший стек, тогда как поток ОС резервирует мегабайты сразу. Вторая — планирование в user space: рантайм переключает горутины сам, без дорогого системного вызова и перехода в режим ядра. Третья — отсутствие отдельных ядерных ресурсов на каждую горутину: их обслуживает пул потоков ОС. Само создание — это, по сути, выделение маленькой структуры g и постановка её в очередь, поэтому спавнить горутины можно щедро (в отличие от потоков).
Источник: go.dev
Как устроена модель планировщика G-P-M?
Короткий ответ
Планировщик Go строится из трёх сущностей: G — горутина, M — поток ОС, который исполняет код, P — логический процессор с локальной очередью готовых горутин и ресурсами для выполнения.
Источник: go.dev
Что такое локальные и глобальные очереди горутин и как они взаимодействуют?
Короткий ответ
У каждого P есть своя локальная очередь готовых горутин (небольшая, вместимость 256), а на весь рантайм — одна глобальная очередь. Планировщик, ища следующую горутину, сначала заглядывает в локальную очередь своего P (это дёшево и без блокировок), периодически — в глобальную, а если пусто — крадёт работу у других P. Локальные очереди снижают конкуренцию за общий ресурс. Чтобы горутины глобальной очереди не голодали, планировщик время от времени (каждый 61-й тик планировщика на P) принудительно берёт горутину из глобальной очереди — иначе локальные могли бы «зациклиться» на себе.
Источник: go.dev
Что такое механизм work stealing в планировщике Go?
Короткий ответ
Work stealing — способ балансировки нагрузки: когда у P опустела локальная очередь, он забирает примерно половину горутин из локальной очереди другого, случайно выбранного P.
Источник: go.dev
Какая многозадачность используется в Go — кооперативная или вытесняющая — и как реализовано вытеснение долгих горутин?
Короткий ответ
Сейчас планирование в Go вытесняющее: с Go 1.14 рантайм прерывает долгие горутины асинхронно, без их участия.
Источник: go.dev
Каналы и select
20 вопросовЧто такое каналы в Go и для чего они применяются?
Короткий ответ
Канал — типизированный конвейер для передачи значений между горутинами со встроенной синхронизацией.
Источник: go.dev
Какие виды каналов существуют в Go?
В чём разница между буферизированным и небуферизированным каналом?
Короткий ответ
Небуферизированный канал синхронен: отправка блокируется, пока другая горутина не начнёт приём. Буферизированный асинхронен на глубину буфера: отправка проходит без ожидания, пока в буфере есть место.
Источник: go.dev
Буферизированный канал с ёмкостью 1 — это то же самое, что небуферизированный?
Короткий ответ
Нет: у канала с буфером 1 первая отправка проходит сразу и не ждёт получателя, а у небуферизированного отправка блокируется до приёма.
Источник: go.dev
Какие операции с каналами блокируют горутину, а какие нет?
Короткий ответ
Отправка блокируется, если некому принять (небуферизированный канал) или буфер полон; приём блокируется, если нет готового значения.
Источник: go.dev
Что произойдёт при записи в закрытый канал, чтении из него и повторном закрытии?
Короткий ответ
Запись в закрытый канал и повторное закрытие паникуют, а чтение из закрытого канала не паникует и не блокируется: отправка в закрытый канал — паника («send on closed channel»), повторное закрытие — паника («close of closed channel»), закрытие nil-канала — тоже паника («close of nil channel»). А вот чтение из закрытого канала безопасно и не блокирует: сначала отдаются все значения, что успели буферизоваться, а затем чтение немедленно возвращает нулевое значение типа, и форма с ok (
v, ok := <-ch) даёт ok == false.Источник: go.dev
Примитивы синхронизации
15 вопросовЧто такое мьютекс (sync.Mutex) и для решения каких задач он применяется?
Короткий ответ
sync.Mutex— взаимная блокировка: в каждый момент её удерживает только одна горутина;Lockзахватывает мьютекс (блокируясь, если он занят),Unlockосвобождает.Источник: pkg.go.dev
Чем sync.RWMutex отличается от sync.Mutex и когда его предпочтительнее использовать?
Короткий ответ
sync.RWMutexразличает блокировку на чтение (RLock/RUnlock) и на запись (Lock/Unlock): по документации, блокировку могут удерживать произвольное число читателей или один писатель.Источник: pkg.go.dev
Могут ли несколько горутин одновременно держать блокировку на чтение в RWMutex?
Короткий ответ
Да:
RLockодновременно могут держать сколько угодно горутин, пока нет писателя; блокировка записиLockэксклюзивна, она ждёт освобождения всех читателей и на время удержания никого не пускает.Источник: pkg.go.dev
Для чего нужна sync.WaitGroup и как с ней работать?
Короткий ответ
WaitGroup ждёт завершения группы горутин. Работает как счётчик:
Add(n)увеличивает его на число запускаемых горутин, каждая по завершении вызываетDone()(уменьшает на 1, обычно через defer), аWait()блокирует, пока счётчик не станет нулём. Это идиоматичный способ «запустить N задач и дождаться всех». С Go 1.25 запуск задачи есть в самой группе:wg.Go(task)сам делает Add(1) и Done, и документация советует предпочитать его ручной паре Add/Done.Источник: pkg.go.dev
Почему wg.Add должен вызываться до запуска горутины и к чему приводит нарушение этого правила?
Короткий ответ
Add нужно вызывать в той же горутине, что запускает новую, до самого
go. Если сделать Add уже внутри запущенной горутины, возникает гонка с Wait: главная горутина может дойти до Wait и увидеть счётчик нулём (нужный Add ещё не выполнился) — Wait вернётся слишком рано, не дождавшись задач. В итоге программа идёт дальше, пока задачи ещё выполняются, а их результаты не готовы.Источник: pkg.go.dev
Конкурентность: гонки, дедлоки, паттерны
18 вопросовВ чём разница между гонкой данных (data race) и состоянием гонки (race condition)?
Короткий ответ
Гонка данных (data race) — конкретный дефект доступа к памяти: запись в ячейку выполняется одновременно с другим чтением или записью той же ячейки без синхронизации. Состояние гонки (race condition) шире: корректность зависит от относительного порядка событий, даже если каждый доступ к памяти синхронизирован.
Источник: go.dev
К каким последствиям приводит гонка данных и почему?
Короткий ответ
Гонка данных в Go — ошибка с тяжёлыми последствиями, а не «просто иногда неверное число»: для значения в одно машинное слово исходы ограничены (чтение видит одну из допустимых записей, в отличие от C/C++), но для многословных значений возможна произвольная порча памяти. Последствия: потерянные обновления, чтение «полузаписанного» значения, а для многословных значений (интерфейс, срез и строка занимают несколько машинных слов, а внутреннее состояние мапы состоит из связанных полей) — рассогласованное состояние, способное привести к порче памяти и падению. Одновременную запись в мапу рантайм, если обнаружит, обрывает fatal-ошибкой «concurrent map writes»; обнаружение best-effort, поэтому полагаться на него нельзя. Причина в том, что без синхронизации нет отношения happens-before: компилятор и процессор вправе переупорядочивать и кэшировать операции с памятью, поэтому одна горутина может вообще не увидеть изменений другой либо увидеть их в неожиданном порядке.
Источник: go.dev
Какие механизмы в Go помогают избежать гонки данных?
Короткий ответ
Гонку данных предотвращает любой механизм, который задаёт отношение happens before между конфликтующими доступами: каналы, мьютексы и атомарные операции.
Источник: go.dev
Как обнаружить гонку данных при разработке?
Короткий ответ
Встроенным детектором гонок: собирать и запускать с флагом
-race—go test -race,go run -race,go build -race. Он инструментирует обращения к памяти и в рантайме отслеживает отношения happens-before; при обнаружении незащищённого конфликтного доступа печатает отчёт со стеками обоих конфликтующих доступов и стеками, где были созданы затронутые горутины.Источник: go.dev
Что такое взаимная блокировка (deadlock) и при каких условиях она возникает?
Короткий ответ
Дедлок — состояние, когда горутины навсегда заблокированы, ожидая друг друга или событие, которое не наступит, и ни одна не может продолжить.
Источник: go.dev
Как рантайм Go обнаруживает дедлок?
Короткий ответ
Рантайм ловит только один частный случай — полный дедлок, когда все горутины заблокированы и ни одна не может продвинуться. Тогда он аварийно завершает программу с сообщением «fatal error: all goroutines are asleep - deadlock!». Но это детекция «всё встало», а не умный анализ: если хотя бы одна горутина работает (например, крутит busy-loop или ждёт сетевой I/O через netpoller), рантайм дедлок НЕ обнаружит — частичные взаимоблокировки, где часть горутин навсегда зависла, а остальные живут, проходят незаметно и выглядят как «утечка горутин» или зависший запрос.
Источник: go.dev
Пакет context
8 вопросовЧто такое context.Context и для решения каких задач он применяется?
Короткий ответ
context.Context — стандартный способ переносить сигнал отмены, дедлайн и небольшой набор request-scoped значений через границы вызовов и горутин.
Источник: pkg.go.dev
Как с помощью context отменить работу горутины и как отмена распространяется?
Короткий ответ
Отменяемый контекст создаёт
context.WithCancel(parent): горутины слушаютctx.Done()и сворачиваются, когда кто-то вызвалcancel(); отмена идёт вниз по дереву контекстов.Источник: pkg.go.dev
Чем контекст с дедлайном отличается от контекста с таймаутом?
Короткий ответ
Это один механизм в двух формах:
WithDeadlineпринимает абсолютный момент времени,WithTimeoutпринимает длительность от текущего момента и реализован какWithDeadline(parent, time.Now().Add(timeout)).Источник: pkg.go.dev
Память, стек, куча и сборщик мусора
18 вопросовЧто такое стек и куча, в чём их принципиальная разница и почему работа с кучей медленнее?
Короткий ответ
Стек — область памяти на каждую горутину, работающая по принципу LIFO: кадр функции получает место при входе и отдаёт его при выходе. Куча — общая область для данных, которые живут дольше вызова функции или разделяются между горутинами.
Источник: go.dev
Что такое escape-анализ, кто и когда его выполняет?
Короткий ответ
Escape-анализ — статический анализ, который компилятор Go выполняет при компиляции: он определяет, выходит ли значение за пределы кадра функции, и от этого зависит, будет ли оно на стеке или в куче.
Источник: go.dev
Как посмотреть, попадёт ли переменная на стек или в кучу?
Короткий ответ
Решения escape-анализа показывает сам компилятор:
go build -gcflags=-m, для подробностей-gcflags=-m=3.Источник: go.dev
Почему возврат указателя на локальную переменную приводит к её аллокации в куче?
Короткий ответ
Если функция возвращает
&local, то указатель продолжает жить у вызывающего после того, как кадр функции уничтожен. Разместить такую переменную на стеке нельзя — стек кадра освобождается на выходе, и указатель повис бы на невалидной памяти. Поэтому escape-анализ признаёт переменную «убегающей» и размещает её в куче, где она живёт, пока на неё есть ссылки.Источник: go.dev
В каких областях памяти могут аллоцироваться переменные в Go и кто решает где?
Короткий ответ
Переменные Go размещаются на стеке горутины или в куче, и место выбирает компилятор, а не программист.
Источник: go.dev
Какой алгоритм использует сборщик мусора в Go и как он работает?
Короткий ответ
Сборщик мусора Go — трассирующий, конкурентный, трёхцветный, mark-and-sweep, неперемещающий и без поколений.
Источник: go.dev
Стандартная библиотека и рантайм
7 вопросовКак работает сериализация в encoding/json, за что отвечают теги структур и когда важно проверять ошибку маршалинга?
Короткий ответ
json.Marshalрекурсивно обходит значение и кодирует его в JSON,json.Unmarshalделает обратное; поведением полей управляют теги структуры, а ошибку нужно проверять всегда.Источник: pkg.go.dev
Что такое рефлексия (пакет reflect), для чего она нужна и почему считается медленной?
Короткий ответ
Рефлексия (пакет
reflect) позволяет программе во время выполнения исследовать типы и значения, не зная их статически:reflect.TypeOfиreflect.ValueOfдают доступ к типу и значению.Источник: pkg.go.dev
Какие возможности предоставляет пакет runtime для интроспекции программы?
Короткий ответ
Для интроспекции runtime даёт сведения о среде (NumGoroutine — число существующих горутин, NumCPU — число логических процессоров, доступных процессу, GOMAXPROCS(0) — текущий предел числа процессоров, на которых одновременно исполняется Go-код, а также Version, GOOS и GOARCH), статистику памяти (ReadMemStats — куча и GC через структуру MemStats) и стеки вызовов (Stack, Caller, Callers); профили и трассировку дают runtime/pprof и runtime/trace. Для управления выполнением есть Gosched (уступить процессор), GC (форсировать сборку), SetFinalizer и KeepAlive (достижимость объектов; в новом коде вместо SetFinalizer рекомендуется AddCleanup, Go 1.24).
Источник: pkg.go.dev
Тестирование
15 вопросовЧем модульный (unit) тест принципиально отличается от интеграционного?
Короткий ответ
Модульный тест проверяет одну единицу кода (функцию, метод, тип) в изоляции от внешних зависимостей, а интеграционный проверяет, что несколько компонентов работают вместе с реальными зависимостями.
Источник: pkg.go.dev
Какие подходы и инструменты используются для написания тестов в Go?
Короткий ответ
Основа тестирования в Go — встроенный пакет
testingи командаgo test.Источник: pkg.go.dev
Что такое table-driven тесты и почему это идиоматичный подход в Go?
Короткий ответ
Table-driven тест — это когда набор случаев описывают как срез структур (обычно поля: имя случая, входные данные, ожидаемый результат), а затем в цикле прогоняют каждый случай, запуская его как подтест через t.Run(tc.name, func(t *testing.T) { ... }).
Источник: pkg.go.dev
Зачем нужны моки при тестировании и какие инструменты их генерации существуют?
Короткий ответ
Мок — это тестовый двойник зависимости, который реализует тот же интерфейс, что и настоящая зависимость, но с управляемым поведением: он нужен, чтобы протестировать единицу кода в изоляции — не ходить в реальную базу или сеть, задать нужные ответы и при необходимости проверить, что и с какими аргументами было вызвано. В Go это опирается на маленькие интерфейсы и принцип «принимай интерфейсы»: код зависит от интерфейса, а в тест подставляется двойник. Часто достаточно написать двойник руками (простой фейк или стаб — идиоматично и без зависимостей). Для генерации есть инструменты: go.uber.org/mock (mockgen, наследник gomock) и mockery, который создаёт моки под testify/mock; сам пакет testify/mock ничего не генерирует, моки в нём пишут вручную.
Источник: pkg.go.dev
Как реализовать проверки (assertions) в тестах, используя только стандартную библиотеку testing?
Короткий ответ
В пакете testing намеренно нет функций-ассертов: проверку пишут вручную обычным if и при несовпадении вызывают t.Errorf (пометить провал и продолжить) или t.Fatalf (сообщить и остановить тест). Базовый шаблон — «if got != want { t.Errorf("Foo() = %v, want %v", got, want) }». Для сравнения сложных значений (срезы, мапы, структуры) берут reflect.DeepEqual (а для срезов и мап ещё slices.Equal и maps.Equal); если внешняя зависимость допустима, google/go-cmp (не входит в стандартную библиотеку) через cmp.Diff даёт читаемый дифф несовпадения. Общие проверки удобно вынести во вспомогательную функцию и пометить её t.Helper(), тогда сообщение об ошибке укажет на строку вызова в тесте, а не внутрь помощника.
Источник: pkg.go.dev
Профилирование и инструменты
5 вопросовДля чего используется pprof и что можно увидеть с его помощью?
Короткий ответ
pprof— семплирующий профилировщик Go и инструментgo tool pprof, который показывает, на что программа тратит ресурсы, и помогает найти горячие точки.Источник: go.dev
Как подключить и использовать pprof в веб-сервисе на Go?
Короткий ответ
В веб-сервисе pprof подключают импортом ради побочного эффекта: import \_ "net/http/pprof" — этот импорт регистрирует HTTP-обработчики по путям /debug/pprof/ на стандартном мультиплексоре. Если своего HTTP-сервера нет, поднимают отдельный (например, go func() { http.ListenAndServe("localhost:6060", nil) }()). Дальше профили снимают инструментом go tool pprof прямо по URL: go tool pprof http://localhost:6060/debug/pprof/heap для кучи, http://localhost:6060/debug/pprof/profile?seconds=30 для 30-секундного CPU-профиля, http://localhost:6060/debug/pprof/goroutine для стеков горутин; block- и mutex-профили заработают после включения через runtime.SetBlockProfileRate и runtime.SetMutexProfileFraction. По пути /debug/pprof/trace?seconds=5 забирают execution trace для go tool trace. С Go 1.22 все эти эндпоинты обслуживают только GET. Если сервис использует собственный мультиплексор, а не DefaultServeMux, обработчики нужно зарегистрировать на нём вручную.
Источник: pkg.go.dev
Почему постоянное профилирование через pprof не рекомендуется в production?
Короткий ответ
Профилировать production можно (документация Go считает это безопасным), но держать профили включёнными постоянно и выставлять /debug/pprof/ наружу не стоит: эндпоинты раскрывают внутренности процесса, а часть профилей стоит производительности. Эндпоинты /debug/pprof/ раскрывают внутренности процесса: командную строку, стеки всех горутин, карту памяти. Открыть их в публичный интернет — значит отдать чувствительную информацию и получить вектор DoS (снятие профиля само нагружает сервис), поэтому их нельзя выставлять наружу без аутентификации, а лучше держать на отдельном внутреннем порту.
Источник: pkg.go.dev
Модули и сборка
14 вопросовДля чего нужны файлы go.mod и go.sum?
Короткий ответ
go.modописывает модуль и его зависимости, аgo.sumхранит контрольные суммы этих зависимостей для проверки целостности.Источник: go.dev
Во что компилируется программа на Go и что такое статическая линковка?
Короткий ответ
go build компилирует исходный код Go в машинный код и линкует его в один исполняемый файл. По умолчанию бинарник статически слинкован: все Go-зависимости и сам рантайм Go (включая сборщик мусора и планировщик) вшиты внутрь файла, внешних .so/динамических Go-зависимостей нет. Практическое следствие — деплой сводится к копированию одного самодостаточного файла, что особенно удобно для контейнеров (например, образ from scratch). Статическая линковка означает, что зависимый код включён в бинарник на этапе сборки, а не подгружается динамически при запуске.
Источник: pkg.go.dev
Как выполнить кросс-компиляцию под другую ОС и архитектуру с помощью GOOS и GOARCH?
Короткий ответ
Кросс-компиляция в Go делается заданием двух переменных окружения перед сборкой: GOOS — целевая операционная система (например, linux, windows, darwin), GOARCH — целевая архитектура (amd64, arm64, 386 и др.). Например, GOOS=linux GOARCH=arm64 go build соберёт бинарник под Linux/ARM64 прямо с вашей машины. Для чистого Go-кода это работает без целевой машины и без установки отдельного тулчейна: компилятор Go умеет генерировать код под все поддерживаемые платформы «из коробки», а результат — самодостаточный статический бинарник. Список допустимых пар GOOS/GOARCH фиксирован для версии Go. Основная сложность — cgo: там для сборки под другую платформу нужен кросс-компилятор C, поэтому при кросс-сборке часто ставят
CGO_ENABLED=0. Простота кросс-компиляции — одна из заметных сильных сторон Go.Источник: pkg.go.dev
Как работает функция init и в каком порядке инициализируются пакеты?
Короткий ответ
init— специальная функция без параметров и результатов (func init()), которую вызывает рантайм при инициализации пакета; зависимые пакеты инициализируются раньше импортирующих.Источник: go.dev
Как в Go-модулях работает версионирование зависимостей?
Короткий ответ
Зависимости версионируются по semver (
vMAJOR.MINOR.PATCH), а нужные версии выбирает алгоритм minimal version selection (MVS):goберёт для каждого модуля наибольшую из минимально требуемых версий в графе зависимостей, а не самую свежую.Источник: go.dev
HTTP-сервер и net/http
10 вопросовЧем интерфейс http.Handler отличается от http.HandlerFunc?
Короткий ответ
http.Handler— интерфейс с единственным методомServeHTTP(ResponseWriter, *Request), аhttp.HandlerFunc— тип-функция, которая этот интерфейс реализует и превращает обычную функцию вHandler. Любой тип, реализующий интерфейс, может обслуживать запросы.Источник: pkg.go.dev
Как устроена маршрутизация в http.ServeMux и что изменилось в Go 1.22?
Короткий ответ
ServeMuxсопоставляет запрос с зарегистрированным шаблоном. Исторически он умел немного: точные пути и префиксы, заканчивающиеся на/, причём выигрывал самый длинный совпавший префикс, а метод запроса не учитывался вовсе.Источник: go.dev
Почему важен порядок вызовов при записи ответа через http.ResponseWriter?
Короткий ответ
Заголовки уходят клиенту в момент, когда впервые записывается тело или явно вызывается
WriteHeader. После этого менятьw.Header()бессмысленно: изменения никуда не попадут, а повторныйWriteHeaderвызовет предупреждение о «superfluous WriteHeader».Источник: pkg.go.dev
Middleware и композиция обработчиков
6 вопросовКак реализуется middleware в Go и почему это просто функция?
Короткий ответ
Middleware — функция вида
func(http.Handler) http.Handler: она принимает обработчик и возвращает новый, который что-то делает до и после вызова вложенного.Источник: pkg.go.dev
Почему порядок middleware имеет значение — на конкретных примерах?
Короткий ответ
Потому что каждый слой решает, вызывать ли следующий, и видит только то, что произошло внутри него.
Источник: pkg.go.dev
Что произойдёт при панике в обработчике и зачем свой recover?
Короткий ответ
net/httpсам восстанавливается после паники в обработчике: сервер логирует стек и закрывает соединение (в HTTP/2 сбрасывает поток), но процесс не падает. Однако клиент при этом получает разрыв, а не осмысленный ответ, и в логе оказывается лишь стандартное сообщение.Источник: pkg.go.dev
JSON и сериализация
6 вопросовВо что превращается произвольный JSON при разборе в interface{}?
Короткий ответ
В фиксированный набор типов: объект — в
map[string]interface{}, массив — в[]interface{}, строка — вstring, логическое — вbool,null— вnil, а любое число — в `float64`.Источник: pkg.go.dev
Как задать собственное представление типа в JSON?
Короткий ответ
Реализовать
json.Marshaler— методMarshalJSON() ([]byte, error)— и симметричноjson.Unmarshalerс методомUnmarshalJSON([]byte) error. Кодировщик вызовет их вместо стандартного поведения.Источник: pkg.go.dev
Доступ к данным
5 вопросовСервис на Go с database/sql под нагрузкой упёрся в max_connections PostgreSQL. Какие настройки пула вы проверите и какие у них значения по умолчанию?
Короткий ответ
Проверяют
SetMaxOpenConns,SetMaxIdleConns,SetConnMaxLifetimeиSetConnMaxIdleTimeу*sql.DB.Источник: go.dev
Почему после db.QueryContext в Go нужно закрывать rows и проверять rows.Err, и что случится, если ранний return выйдет из цикла по строкам?
Короткий ответ
Пока
Rowsне закрыт, он удерживает соединение пула, поэтому незакрытыеRowsисчерпывают пул, и новые запросы будут ждать бесконечно.Источник: pkg.go.dev
Как правильно написать транзакцию в Go через database/sql с контекстом, чтобы при ошибке и при отмене запроса она откатывалась, а внутри использовалась одна и та же транзакция?
Короткий ответ
Начинают транзакцию
tx, err := db.BeginTx(ctx, nil), сразу откладываютdefer tx.Rollback()и вызываютtx.Commit()в конце; все запросы внутри идут черезtx.ExecContext/tx.QueryContext, а не черезdb.Источник: pkg.go.dev
HTTP API: условные запросы и версии
4 вопросаКак в Go-обработчике ответить 304 Not Modified, если клиент прислал If-None-Match с актуальным ETag?
Короткий ответ
Нужно вычислить ETag ресурса, сравнить его с заголовком
If-None-Matchи при совпадении вернуть 304 без тела; в остальных случаях отдать ответ с заголовкомETag.Источник: pkg.go.dev
Какие изменения REST API считаются ломающими, как вынести версию в путь /v1/ в Go на стандартном ServeMux и когда пора заводить /v2/?
Короткий ответ
Ломающие изменения это те, что ломают существующих клиентов: удаление или переименование поля, смена его типа или смысла, новое обязательное поле запроса, изменение кода ответа. Добавление необязательного поля в ответ и нового эндпоинта совместимо, при условии что клиенты игнорируют незнакомые поля.
Источник: pkg.go.dev
Обработчик вызывает
http.ServeContentи перед вызовом ставитETag: "v7", время изменения содержимого передано 19 октября 2026 12:00:00 UTC. Клиент присылаетGETс заголовкамиIf-None-Match: "v6"иIf-Modified-Since: Mon, 19 Oct 2026 12:00:01 GMT. Что ответитServeContentи почему?Короткий ответ
Полный ответ
200с телом:If-Modified-Sinceпри наличииIf-None-Matchне учитывается.Источник: pkg.go.dev
Конфигурация и отказоустойчивость
4 вопросаЧто принцип «Config» из методологии twelve-factor считает конфигурацией, где её хранить и как проверить, что граница проведена верно?
Короткий ответ
Конфигурация это всё, что отличается между развёртываниями (staging, production): адреса БД и сервисов, учётные данные, ключи внешних API. Её хранят в переменных окружения, а не в коде и не в файлах репозитория.
Источник: 12factor.net
В Go-сервисе os.Getenv вызывается в десятке мест, а отсутствие обязательной переменной обнаруживается только при первом обращении. Как организовать загрузку конфигурации?
Короткий ответ
Читать окружение один раз при старте в единую структуру
Config, проверять её и передавать зависимостям явно; при ошибке сервис не запускается.Источник: 12factor.net
Как в Go написать повтор вызова внешнего сервиса при ошибке 503, чтобы он не усугублял перегрузку, и что делать с отменой контекста во время ожидания?
Короткий ответ
Повторять ограниченное число раз с экспоненциально растущей паузой, добавлять случайный разброс (jitter), ограничивать максимум паузы и прерывать ожидание по отмене контекста.
Источник: aws.amazon.com
Наблюдаемость
4 вопросаКак с помощью log/slog записать запись с типизированными атрибутами и сгруппировать часть из них под общим ключом, и как это выглядит в JSON?
Короткий ответ
Сообщение и пары ключ-значение передают в
logger.Info, группу создаютslog.Group, постоянные атрибуты привязываютlogger.With.Источник: pkg.go.dev
Как добавить в каждую запись slog идентификатор трассировки из context.Context, не передавая его вручную в каждый вызов?
Короткий ответ
Вызывать методы с контекстом (
logger.InfoContext(ctx, ...)) и обернуть обработчик своимslog.Handler, который достаёт значение изctxи добавляет его атрибутом вHandle.Источник: pkg.go.dev
Как трассировка OpenTelemetry связывает спаны двух сервисов на Go, когда один вызывает другой по HTTP?
Короткий ответ
Контекст трассировки передаётся в заголовках запроса: клиент инжектирует его пропагатором, сервер извлекает, и новый спан становится дочерним.
Источник: opentelemetry.io
gRPC в Go
6 вопросовЧем
grpc.NewClientотличается отgrpc.Dialиgrpc.DialContext: когда устанавливается соединение, какой резолвер используется по умолчанию и что станет с опциейWithBlock?Короткий ответ
NewClientсоздаёт канал без ввода-вывода и соединяется при первом вызове, аDialиDialContextустарели: они начинают соединяться сразу, по умолчанию берут резолверpassthroughи поддерживаютWithBlock, которыйNewClientигнорирует.Источник: pkg.go.dev
При остановке сервис вызывает
server.GracefulStop(), но процесс не завершается, пока открыт серверный поток подписки. Почему и как ограничить время остановки?Короткий ответ
GracefulStopблокируется, пока не завершатся все идущие вызовы, а серверный поток подписки сам не заканчивается, поэтому метод не возвращается. Время ограничивают отдельным таймером, по которому вызываютStop.Источник: pkg.go.dev
Обработчик сервиса заказов вызывает сервис оплаты с тем же
ctx. Дедлайн дошёл до сервиса оплаты, а заголовокx-request-idиз входящих метаданных — нет. Почему и как его передать?Короткий ответ
Дедлайн хранится в самом
ctx, а метаданные входящего и исходящего вызова лежат в контексте раздельно: исходящий вызов берёт заголовки только из исходящих метаданных, и входящие туда сами не попадают. Заголовок копируют явно: читают из входящих и добавляют в исходящие.Источник: pkg.go.dev
