JavaRush /Курсы /Go SELF /Чтение stack trace и типовые runtime panic’и

Чтение stack trace и типовые runtime panic’и

Go SELF
33 уровень, 0 лекция
Открыта

1. Stack trace как подсказка, а не «страшный текст»

Когда программа падает, новичку часто хочется сделать две вещи: обидеться на Go и начать тыкать код палочкой «пока не заработает». Это человеческое желание, но есть способ быстрее: принять, что Go уже написал вам подсказку — просто в формате, похожем на чек из супермаркета.

Stack trace — это распечатка стека вызовов на момент аварии. Если говорить по‑простому, это список функций, которые «прямо сейчас» были в работе, когда случилась беда.

Go печатает stack trace автоматически при panic, потому что panic останавливает обычный поток выполнения и начинает «раскручивать» вызовы назад, выполняя defer (если он есть) и в конце завершая программу. Этот механизм описан в классической статье про defer/panic/recover.

Термины: call stack, stack frame, stack trace, goroutine

Когда вы читаете stack trace, полезно знать пару слов, чтобы не чувствовать себя археологом, которому выдали инструкцию на марсианском.

Call stack (стек вызовов) — это «стопка» активных вызовов функций. Представьте, что main() позвал run(), run() позвал load(), load() позвал parse(), и вот в parse() случилась паника. В этот момент стек — это цепочка main → run → load → parse.

Stack frame (кадр стека) — это один «этаж» этого списка: конкретная функция и место в файле, где она находится.

Stack trace — это печать этих кадров стека в консоль: функция, файл и строка.

Goroutine — это лёгкий поток выполнения в Go. Пока мы не уходим в конкурентность, вам достаточно знать практическую вещь: в сообщении о падении почти всегда будет строка вида goroutine 1 [running]. Это просто «в каком потоке выполнения упали». Обычно у учебных CLI‑программ всё падает в 1, и это нормально.

2. Как устроен stack trace

Любой stack trace в Go удобно читать как документ из трёх смысловых частей. Сейчас будет короткая «расшифровка», и дальше вы начнёте узнавать её почти в каждом падении.

Сообщение panic: ...: что случилось

После заголовка panic: обычно идёт самая короткая формулировка причины: index out of range, nil pointer dereference, divide by zero и так далее. Эту строку полезно читать, но она почти никогда не заменяет переход к конкретной строке кода.

Строка goroutine N [state]: где случилось

Это не «магия», а контекст: в какой горутине и в каком состоянии. Для нас пока это почти всегда будет goroutine 1 [running].

Кадры стека: как мы сюда дошли

Дальше идёт список кадров: имя функции и координаты file:line. И вот тут главный практический лайфхак: ваша цель — найти первый кадр, который относится к вашему коду, а не к runtime/....

4. Главное правило: сначала ищем первую строку вашего проекта

Когда вы видите stack trace, не надо читать всё подряд сверху вниз, как роман. Надо действовать как инженер: найти координату в вашем коде.

Практическая стратегия такая: смотрите на кадры стека и ищите строки, где фигурирует ваш файл (например, main.go, task.go, app.go) или ваш пакет. Всё, что в духе runtime/panic.go, runtime/slice.go, fmt/print.go, — это системные вызовы: они почти никогда не «виноваты», они просто честно фиксируют место, где у вас всё сломалось.

Часто «ваш» кадр будет либо самым верхним, либо одним из первых. Но иногда паника возникает внутри функции, которую вы вызвали, и тогда ваш код будет на строке вызова этой функции.

И ещё один важный нюанс: строка в stack trace показывает место, где ошибка проявилась, но не всегда место, где вы ошиблись логически. Поэтому после прыжка на file:line полезно задавать себе вопрос: «какие значения переменных сюда пришли, что это стало возможным?».

5. Практика: самые частые runtime panic’и

Дальше — типовые падения, которые вы будете видеть чаще всего. Цель тут одна: научиться связывать формулировку паники и координаты file:line с конкретным исправлением в коде.

index out of range: вышли за границы по индексу

Начнём с самого популярного падения.

package main

import "fmt"

func main() {
	nums := []int{10, 20}
	fmt.Println(nums[2]) // тут будет panic
}

При запуске вы увидите что‑то в духе (формат может слегка отличаться по IDE/ОС, но смысл тот же):

panic: runtime error: index out of range [2] with length 2
goroutine 1 [running]:
main.main()
    /path/to/project/main.go:8 +0x...
exit status 2

Что здесь важно: в сообщении уже сказано index out of range, то есть индекс вышел за границы. Но самое полезное — это координаты /path/to/project/main.go:8. Это и есть «телепорт» к проблеме: открываете файл, идёте на строку 8, и вы уже в нужном месте.

Важно помнить простую математику: если длина len(s) == 2, то допустимые индексы — 0 и 1. Индекс 2 — это уже «на улице, без шапки».

Как читать цепочку вызовов, если функций больше одной

Один файл и одна функция — это разогрев. В реальном коде паника часто происходит внутри маленькой функции, которую вызывает другая, а та — третья. Stack trace тогда становится прямо полезным: он показывает маршрут.

Сделаем пример на мини‑версии «учебного приложения», допустим, условного CLI‑менеджера задач. Идея: мы хотим взять задачу по индексу, но забыли проверить границы.

package main

import "fmt"

func mustTask(tasks []string, i int) string {
	return tasks[i] // тут будет panic, если i плохой
}

func main() {
	tasks := []string{"read", "code"}
	fmt.Println(mustTask(tasks, 5))
}

Типичный stack trace будет похож на:

panic: runtime error: index out of range [5] with length 2
goroutine 1 [running]:
main.mustTask()
    /path/to/project/main.go:6 +0x...
main.main()
    /path/to/project/main.go:11 +0x...

Как это читать: main() вызвал mustTask(), а внутри mustTask() случилась паника. Поэтому верхний кадр — mustTask, нижний — main. И вот теперь вы не просто знаете «упали», вы знаете «в какой функции упали и кто её позвал».

slice bounds out of range: неправильные границы слайса

Ещё одна разновидность — паника, когда вы делаете s[a:b] с неправильными границами.

package main

import "fmt"

func main() {
	s := []int{1, 2, 3}
	fmt.Println(s[0:5]) // panic: slice bounds out of range
}

В stack trace вы снова ищете координату вашего файла и строки, и почти всегда прямо на этой строке видно, что 5 больше len(s).

nil pointer dereference: разыменовали nil

Вторая классика — panic: runtime error: invalid memory address or nil pointer dereference. Звучит как заклинание, но означает простую вещь: вы попытались обратиться к полю или методу через указатель, который равен nil.

package main

import "fmt"

type Config struct {
	Limit int
}

func main() {
	var cfg *Config
	fmt.Println(cfg.Limit) // panic: cfg == nil
}

Тут важно связать это с тем, что вы уже знаете: var cfg *Config не создаёт объект Config, он создаёт переменную‑указатель со значением nil. Если бы вы сделали cfg := &Config{Limit: 10}, всё было бы нормально.

Механика panic и то, что при панике выполняются defer по пути «раскрутки» стека, описана в статье про defer/panic/recover.

integer divide by zero: деление на ноль

Деление на ноль в Go не «даёт ошибку», а именно падает паникой (для целых чисел). Это часто случается в расчётах вроде «среднее значение», «процент», «делим сумму на количество».

package main

import "fmt"

func main() {
	total := 10
	count := 0
	fmt.Println(total / count) // panic: integer divide by zero
}

В реальном приложении count часто становится нулём из‑за пустого ввода: пустой слайс, пустой файл, пользователь ничего не ввёл, фильтр всё отфильтровал. И вот тут stack trace помогает не «понять математику», а найти конкретную строку, где вы делите, и задуматься: «а что если count == 0?».

assignment to entry in nil map: запись в nil map

Карты (map) вы уже знаете, и там есть тонкий, но очень практичный момент: читать из nil map можно, а писать — нельзя. Попытка записать приводит к панике assignment to entry in nil map.

package main

import "fmt"

func main() {
	var counts map[string]int
	counts["go"]++          // panic: assignment to entry in nil map
	fmt.Println(counts["go"])
}

Почему это важно для чтения stack trace: если вы видите такую формулировку, почти всегда причина одна — вы забыли make(map[...]). И координаты в stack trace покажут, где именно вы впервые попытались писать в карту.

interface conversion: небезопасный type assertion

Эта паника чаще встречается, когда вы начинаете использовать any и интерфейсы. Суть: выражение v.(T) без проверки ok может паниковать, если реальный тип другой.

package main

import "fmt"

func main() {
	var v any = 10
	s := v.(string) // panic: interface conversion: int is not string
	fmt.Println(s)
}

В stack trace вы увидите строку с v.(string) — и это будет честный указатель: «вот место, где вы были слишком уверены в типе». Правильный стиль — использовать безопасную форму s, ok := v.(string) и обрабатывать ok == false. Сама идея type assertion у вас уже встречалась в курсе, а позже будет раскрываться глубже.

6. Откуда берётся stack trace: runtime panic и panic(...) от вас

Важно отличать два источника паники.

Первый — runtime panic: когда Go сам падает из‑за нарушения правил исполнения (вышли за границы, разыменовали nil, поделили на ноль). В сообщении обычно есть фраза runtime error:.

Второй — ваш panic("что-то пошло не так"). Он полезен редко (обычно в ситуациях «это невозможно по логике программы»), но иногда встречается в учебном коде или прототипах.

package main

func main() {
	panic("config is missing") // осознанная паника
}

И в том, и в другом случае Go печатает stack trace: потому что механика одна и та же — аварийное завершение и раскрутка стека.

7. Что делать, когда увидели падение

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

flowchart TD
    A["Программа упала: panic + stack trace"] --> B["Смотрим panic-сообщение (тип проблемы)"]
    B --> C["Ищем первый кадр вашего кода (ваш файл:строка)"]
    C --> D["Открываем строку и формулируем гипотезу: какие значения сюда пришли?"]
    D --> E["Проверяем инварианты: границы, nil, ноль, тип"]
    E --> F["Исправляем: проверка + нормальная ветка поведения"]

Эта схема проста, но она дисциплинирует: вы перестаёте «чинить всё подряд» и чините конкретное место по координатам.

8. defer при панике: почему это иногда видно в выводе

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

При панике Go «раскручивает» стек: выходит из текущей функции, выполняя её deferred‑вызовы, затем выходит из вызывающей функции, выполняя её deferred‑вызовы, и так далее, пока не дойдёт до верха горутины. Это ровно та механика, на которой держится гарантированное закрытие файлов и освобождение ресурсов.

Практически это означает: если у вас были defer fmt.Println("cleanup"), вы можете увидеть эти печати прямо перед тем, как программа окончательно упадёт. Это не «призрак», а нормальная логика: паника не отменяет defer.

9. Типичные ошибки при чтении stack trace

Ошибка №1: читать только строку panic: ... и игнорировать file:line.
Сообщение о панике говорит «что случилось», но не говорит «где именно». Ваш реальный якорь — это координаты файла и строки. Если приучить себя сразу прыгать в file:line, скорость диагностики растёт радикально.

Ошибка №2: утонуть в runtime/... и пытаться чинить стандартную библиотеку.
Почти любой stack trace содержит кадры runtime и иногда fmt. Это не значит, что Go «сломался». Это значит, что Go честно показал, где он заметил вашу ошибку. Ищите первый кадр с вашим файлом — это почти всегда и есть точка входа в расследование.

Ошибка №3: путать “длину” и “последний индекс”.
len(s) — это количество элементов, а последний индекс — len(s) - 1. Ошибка index out of range очень часто случается от того, что человек мысленно считает длину «как последний индекс». Stack trace покажет строку, но причину лучше лечить пониманием границ.

Ошибка №4: не видеть nil там, где «по идее» объект должен быть.
nil pointer dereference почти всегда означает, что переменная‑указатель так и осталась nil: её не инициализировали, или инициализация была в ветке, которая не выполнилась. Stack trace помогает найти место падения, но дальше нужно привычкой проверять «а могло ли оно быть nil?».

Ошибка №5: считать любую панику “нормальной ошибкой” и пытаться её “замолчать”.
Иногда хочется просто поставить recover где-нибудь поглубже и «пусть не падает». Но panic — это сигнал «у вас баг или нарушен инвариант», и прятать его — значит откладывать проблему. В Go обычно recover ставят на границе приложения, чтобы превратить падение в аккуратное сообщение и лог, но сам баг всё равно должен быть исправлен. Эта мысль хорошо отражена в обсуждениях обработки паник на границе приложения.

1
Задача
Go SELF, 33 уровень, 0 лекция
Недоступна
Индекс без паники
Индекс без паники
1
Задача
Go SELF, 33 уровень, 0 лекция
Недоступна
Счётчик слов
Счётчик слов
1
Задача
Go SELF, 33 уровень, 0 лекция
Недоступна
Среднее без нуля
Среднее без нуля
1
Задача
Go SELF, 33 уровень, 0 лекция
Недоступна
Конфиг без падения
Конфиг без падения
Комментарии
ЧТОБЫ ПОСМОТРЕТЬ ВСЕ КОММЕНТАРИИ ИЛИ ОСТАВИТЬ КОММЕНТАРИЙ,
ПЕРЕЙДИТЕ В ПОЛНУЮ ВЕРСИЮ