defer, panic и recover — бесплатный тест онлайн

Вопрос 1 из 25

В разделе «Порядок defer» показан конкретный случай. Какой результат даст этот код на поддерживаемой реализации Go?

// Фрагмент для трассировки.
package main
import "fmt"
func main(){ for i:=1;i<=3;i++{ defer fmt.Print(i," ") } }

Функция возвращает ненулевую ошибку при отрицательном входе, а вызывающий код может обработать её без паники. Код печатает `3 2 1`, потому что три `defer` снимаются как стек после выхода из функции. Цикл напечатает `0 1 2`, после чего `break` завершит только самую внутреннюю конструкцию `for`. Код печатает `0 false ""`, потому что переменные объявлены, но им ничего не присвоено. Код печатает `есть: 2`; переменная `n` существует только внутри `if` и `else`.

Вопрос 2 из 25

Команда проверяет решение по теме «Порядок defer». Что нужно поменять, чтобы граничный случай не превратился в сбой?

// Фрагмент из ревью: требуется выбрать безопасную правку.
package main
import "fmt"
func main(){ for i:=1;i<=3;i++{ defer fmt.Print(i," ") } }

Использовать явный `return value`, если изменение результата через `defer` не является намеренной и хорошо объяснённой частью контракта. Использовать `defer` рядом с успешным захватом ресурса и не прятать в нём критически важную бизнес-логику. Возвращать значение и ошибку, когда отсутствие результата вызвано сбоем, а не кодировать ошибку магическим числом. Использовать инициализацию в `if`, когда промежуточное значение не нужно после проверки. Использовать метку, когда она делает цель выхода очевидной; при сложной логике лучше вынести поиск в отдельную функцию и вернуть результат.

Вопрос 3 из 25

Перед публикацией кода по теме «Порядок defer» нужно уточнить контракт. Какое свойство конструкции определяет её поведение?

// Определите правило Go, которое объясняет результат.
package main
import "fmt"
func main(){ for i:=1;i<=3;i++{ defer fmt.Print(i," ") } }

Именованные результаты являются локальными переменными и участвуют в `return` без выражений, но могут быть изменены отложенной функцией. Ошибка — значение, обычно возвращаемое отдельным результатом; `errors.New` подходит для постоянного сообщения без форматирования. `errors.Is` проходит цепочку обёрток и учитывает методы `Is`; обычное `==` видит только непосредственно сравнимое значение. Go не выполняет неявное числовое преобразование между именованными типами; преобразование пишется явно. Отложенные вызовы выполняются в обратном порядке регистрации; аргументы обычного отложенного вызова вычисляются сразу.

Вопрос 4 из 25

В рабочем примере по теме «Порядок defer» важно отделить гарантию от догадки. Что стоит проверить до переноса решения в общий компонент?

Короткое объявление во вложенном блоке может затенить внешнюю переменную и оставить её значение неизменным. Нельзя использовать многозначный вызов как один аргумент рядом с другими аргументами, если сигнатура не допускает точного разворачивания. Изменение длины среза внутри `range` не заставляет цикл заново вычислять число итераций. В цикле отложенные вызовы выполнятся только при выходе из окружающей функции, что может слишком долго удерживать ресурсы. Голый `return` в длинной функции усложняет понимание, какое значение фактически возвращается.

Вопрос 5 из 25

Фрагмент относится к теме «Порядок defer». Как точнее всего описать пользу и цену этого решения?

Variadic удобен для небольшого необязательного набора, но срез яснее, когда коллекция является самостоятельным объектом данных. Sentinel упрощает ветвление, но публичный набор категорий становится частью совместимости пакета. Именованные результаты полезны для документации и коротких функций, но скрытая мутация результата повышает цену ревью. Обычный `for` даёт полный контроль, а `range` короче и безопаснее для обхода, но скрывает часть деталей индексации. `defer` упрощает освобождение, но в большом цикле отдельная вспомогательная функция часто задаёт более короткое время жизни.

Вопрос 6 из 25

Команда проверяет решение по теме «Паника». К какому результату приводит показанная конструкция?

// Фрагмент для трассировки.
package main
import "fmt"
func main(){ defer fmt.Println("cleanup"); panic("broken invariant") }

Сложение `Meters` и `int` не компилируется, пока один операнд не будет явно преобразован. Цикл напечатает `0 1 2`, после чего `break` завершит только самую внутреннюю конструкцию `for`. Функция возвращает ненулевую ошибку при отрицательном входе, а вызывающий код может обработать её без паники. Перед завершением программы отложенный `fmt.Println("cleanup")` выполнится, а затем будет напечатана трассировка паники. Отложенная функция увеличивает именованный результат, поэтому `answer()` возвращает `2`, а не `1`.

Вопрос 7 из 25

Перед публикацией кода по теме «Паника» нужно уточнить контракт. Какую правку стоит предложить на ревью, сохранив назначение кода?

// Фрагмент из ревью: требуется выбрать безопасную правку.
package main
import "fmt"
func main(){ defer fmt.Println("cleanup"); panic("broken invariant") }

Для фоновой работы связывать цикл с `context` или каналом завершения, а не оставлять его без пути остановки. Добавлять контекст на границе операции, не повторяя уже понятные уровни и не теряя исходную ошибку. Возвращать ошибку для ожидаемых отказов; панику оставлять для нарушенного внутреннего инварианта или невозможной инициализации. Использовать инициализацию в `if`, когда промежуточное значение не нужно после проверки. Использовать `=` при повторном присваивании всех имён; `:=` оставлять для появления хотя бы одного нового имени.

Вопрос 8 из 25

В рабочем примере по теме «Паника» важно отделить гарантию от догадки. На какой контракт языка или стандартной библиотеки здесь нужно опереться?

// Определите правило Go, которое объясняет результат.
package main
import "fmt"
func main(){ defer fmt.Println("cleanup"); panic("broken invariant") }

Go не выполняет неявное числовое преобразование между именованными типами; преобразование пишется явно. `errors.Is` проходит цепочку обёрток и учитывает методы `Is`; обычное `==` видит только непосредственно сравнимое значение. Оператор `:=` допустим внутри функций и требует хотя бы одну новую переменную в текущем блоке. Ошибка — значение, обычно возвращаемое отдельным результатом; `errors.New` подходит для постоянного сообщения без форматирования. `panic` прекращает обычное выполнение текущей горутины и запускает раскрутку стека с выполнением `defer`.

Вопрос 9 из 25

Фрагмент относится к теме «Паника». Какое ограничение опаснее всего пропустить?

`fallthrough` переходит в следующую ветвь без проверки её выражения. `defer` не выполняется при `os.Exit`, поэтому такой выход нельзя считать обычным завершением функции. Изменение длины среза внутри `range` не заставляет цикл заново вычислять число итераций. Паника в фоновой горутине без восстановления завершает весь процесс, а не только эту горутину. Только один операнд `%w` обычно соответствует одной оборачиваемой ошибке; форматирование `%v` не создаёт цепочку.

Вопрос 10 из 25

На ревью разбирают тему «Паника». Какой вывод о сопровождении решения наиболее взвешенный?

Метки иногда проще флагов состояния, но большое число переходов быстро разрушает локальную понятность кода. Короткая область видимости уменьшает случайные зависимости, но слишком плотная строка ухудшает чтение сложного условия. Паника быстро выявляет невозможное состояние, но как обычный протокол ошибок она лишает вызывающий код явного выбора. Обычный `for` даёт полный контроль, а `range` короче и безопаснее для обхода, но скрывает часть деталей индексации. Variadic удобен для небольшого необязательного набора, но срез яснее, когда коллекция является самостоятельным объектом данных.

Вопрос 11 из 25

Перед публикацией кода по теме «Восстановление recover» нужно уточнить контракт. Как завершится показанный фрагмент при указанных входных данных?

// Фрагмент для трассировки.
package main
func run(){ defer func(){ _=recover() }(); panic("boom") }
func main(){ run() }

Отложенная функция получает значение `"boom"`, и программа продолжает выполнение после завершения функции `run`. Отложенная функция увеличивает именованный результат, поэтому `answer()` возвращает `2`, а не `1`. Для `n == 2` код печатает только `small`, потому что после совпавшего `case` выполнение выходит из `switch`. Функция возвращает `7, nil`; запись `n, err := parse()` корректно получает оба результата. Функция возвращает ненулевую ошибку при отрицательном входе, а вызывающий код может обработать её без паники.

Вопрос 12 из 25

В рабочем примере по теме «Восстановление recover» важно отделить гарантию от догадки. Что здесь следует изменить прежде всего?

// Фрагмент из ревью: требуется выбрать безопасную правку.
package main
func run(){ defer func(){ _=recover() }(); panic("boom") }
func main(){ run() }

Назначать константе явный тип, когда контракт API должен фиксировать диапазон или представление. Возвращать значение и ошибку, когда отсутствие результата вызвано сбоем, а не кодировать ошибку магическим числом. Преобразовывать на границе и заранее проверять диапазон, если более широкий тип сужается. Восстанавливать панику на чёткой границе, записывать контекст и превращать её в контролируемую ошибку либо безопасный ответ. Добавлять контекст на границе операции, не повторяя уже понятные уровни и не теряя исходную ошибку.

Вопрос 13 из 25

Фрагмент относится к теме «Восстановление recover». Какое правило отделяет верный разбор от правдоподобной догадки?

// Определите правило Go, которое объясняет результат.
package main
func run(){ defer func(){ _=recover() }(); panic("boom") }
func main(){ run() }

Вариативный параметр внутри функции имеет тип среза; существующий срез передают с `...`. `recover` останавливает текущую панику только при вызове внутри отложенной функции той же горутины. Именованные результаты являются локальными переменными и участвуют в `return` без выражений, но могут быть изменены отложенной функцией. Оператор `:=` допустим внутри функций и требует хотя бы одну новую переменную в текущем блоке. `errors.Is` проходит цепочку обёрток и учитывает методы `Is`; обычное `==` видит только непосредственно сравнимое значение.

Вопрос 14 из 25

На ревью разбирают тему «Восстановление recover». Какой крайний случай обязан попасть в тесты?

Вызов `recover()` вне выполняемого `defer` возвращает `nil` и ничего не перехватывает. Нельзя использовать многозначный вызов как один аргумент рядом с другими аргументами, если сигнатура не допускает точного разворачивания. `fallthrough` переходит в следующую ветвь без проверки её выражения. Преобразование целого к меньшему типу отбрасывает старшие биты и не сообщает о переполнении. Голый `return` в длинной функции усложняет понимание, какое значение фактически возвращается.

Вопрос 15 из 25

В разделе «Восстановление recover» показан конкретный случай. Какой выбор лучше отражает баланс простоты и контроля?

Граница восстановления защищает сервер от дефекта одного запроса, но не должна скрывать повреждённое общее состояние. Встроенные типы удобны и быстры, но отдельный именованный тип лучше защищает единицы измерения и предметные ограничения. Метки иногда проще флагов состояния, но большое число переходов быстро разрушает локальную понятность кода. Нетипизированные константы удобны в выражениях, но явный тип полезен на границе пакета и при сериализации. Sentinel упрощает ветвление, но публичный набор категорий становится частью совместимости пакета.

Вопрос 16 из 25

В рабочем примере по теме «Границы восстановления» важно отделить гарантию от догадки. Как изменится состояние программы после этого фрагмента?

// Фрагмент для трассировки.
package main
func main(){
    defer func(){ _=recover() }()
    done:=make(chan struct{})
    go func(){ defer close(done); panic("worker") }()
    <-done
}

Код печатает `есть: 2`; переменная `n` существует только внутри `if` и `else`. Функция возвращает ненулевую ошибку при отрицательном входе, а вызывающий код может обработать её без паники. Цикл напечатает `0 1 2`, после чего `break` завершит только самую внутреннюю конструкцию `for`. Вызов `sum(xs...)` передаёт элементы `xs` как отдельные аргументы и возвращает `6`. Внешний `defer` в `main` не восстановит панику, запущенную внутри отдельной горутины.

Вопрос 17 из 25

Фрагмент относится к теме «Границы восстановления». Какое замечание на ревью будет наиболее точным?

// Фрагмент из ревью: требуется выбрать безопасную правку.
package main
func main(){
    defer func(){ _=recover() }()
    done:=make(chan struct{})
    go func(){ defer close(done); panic("worker") }()
    <-done
}

Назначать константе явный тип, когда контракт API должен фиксировать диапазон или представление. Объединять несколько значений в одном `case`, если им соответствует одно действие, вместо цепочки пустых ветвей. Преобразовывать на границе и заранее проверять диапазон, если более широкий тип сужается. Оставить нулевое значение только там, где оно имеет ясный смысл; иначе создавать значение через конструктор с проверкой. Ставить защиту внутри точки запуска каждой независимой задачи, если процесс должен переживать её панику.

Вопрос 18 из 25

На ревью разбирают тему «Границы восстановления». Какое правило важнее случайных деталей конкретного запуска?

// Определите правило Go, которое объясняет результат.
package main
func main(){
    defer func(){ _=recover() }()
    done:=make(chan struct{})
    go func(){ defer close(done); panic("worker") }()
    <-done
}

Метка у `break` или `continue` позволяет явно воздействовать на внешнюю конструкцию, а не только на ближайший цикл. Нетипизированная константа сохраняет точное значение до контекста, где требуется конкретный тип, если значение представимо. Именованные результаты являются локальными переменными и участвуют в `return` без выражений, но могут быть изменены отложенной функцией. `recover` действует только в той горутине, где возникла паника; родительская горутина не перехватит панику дочерней. `errors.Is` проходит цепочку обёрток и учитывает методы `Is`; обычное `==` видит только непосредственно сравнимое значение.

Вопрос 19 из 25

В разделе «Границы восстановления» показан конкретный случай. Где корректный фрагмент легко становится ошибочным?

После восстановления нельзя автоматически считать частично изменённые данные согласованными. `defer` не выполняется при `os.Exit`, поэтому такой выход нельзя считать обычным завершением функции. Короткое объявление во вложенном блоке может затенить внешнюю переменную и оставить её значение неизменным. Размер `int` зависит от разрядности целевой платформы, поэтому его нельзя молча считать всегда 64-битным. Голый `return` в длинной функции усложняет понимание, какое значение фактически возвращается.

Вопрос 20 из 25

Команда проверяет решение по теме «Границы восстановления». Что учитывать при выборе этого приёма для публичного API?

Метки иногда проще флагов состояния, но большое число переходов быстро разрушает локальную понятность кода. `:=` сокращает шум, но при смешивании новых и старых имён повышает риск незаметного затенения. Локальное восстановление повышает живучесть, но требует чёткой изоляции состояния и наблюдаемого сигнала о дефекте. Sentinel упрощает ветвление, но публичный набор категорий становится частью совместимости пакета. Именованные результаты полезны для документации и коротких функций, но скрытая мутация результата повышает цену ревью.

Вопрос 21 из 25

Фрагмент относится к теме «Тестирование и наблюдаемость». Какой результат даст этот код на поддерживаемой реализации Go?

// Фрагмент для трассировки.
package sample
import "testing"
func TestPanic(t *testing.T){
    defer func(){ if recover()==nil { t.Fatal("panic expected") } }()
    panic("x")
}

Тест ожидает `Rollback`, если второй запрос транзакции завершился ошибкой. Тест считается успешным только если вызов действительно вызвал ожидаемую панику; отсутствие паники — отдельная ошибка теста. Тест с тысячей конкурентных увеличений ожидает точное итоговое значение под мьютексом. Тест использует канал результата и таймаут, поэтому различает успешное завершение и зависание. Точный итог счётчика и чистый `-race` проверяют разные стороны: смысл и отсутствие обнаруженной гонки.

Вопрос 22 из 25

На ревью разбирают тему «Тестирование и наблюдаемость». Что нужно поменять, чтобы граничный случай не превратился в сбой?

// Фрагмент из ревью: требуется выбрать безопасную правку.
package sample
import "testing"
func TestPanic(t *testing.T){
    defer func(){ if recover()==nil { t.Fatal("panic expected") } }()
    panic("x")
}

Использовать короткий контролируемый таймаут, синхронизацию запуска и отдельную проверку причины завершения. Проверять заголовки, контекст, статус, паники и дополнительные интерфейсы ResponseWriter. Выносить проверку паники в небольшую функцию и добавлять `debug.Stack()` в журнал на эксплуатационной границе. Добавлять компиляционные проверки допустимых типов и обычные поведенческие тесты граничных значений. Хранить репрезентативные старые документы в `testdata`, проверять ограничения размера и не журналировать полный чувствительный JSON.

Вопрос 23 из 25

В разделе «Тестирование и наблюдаемость» показан конкретный случай. Какое свойство конструкции определяет её поведение?

// Определите правило Go, которое объясняет результат.
package sample
import "testing"
func TestPanic(t *testing.T){
    defer func(){ if recover()==nil { t.Fatal("panic expected") } }()
    panic("x")
}

Синхронизацию проверяют под `-race`, повторными прогонами и инвариантами результата, а не только отсутствием паники. Клиент тестируют через `httptest.Server` и подменный `RoundTripper`, проверяя статусы, тело, отмену и число попыток. Панику проверяют в той же горутине через отложенный `recover`, а в рабочем сервисе фиксируют значение и стек. Сериализацию проверяют золотыми примерами, круговым преобразованием и испорченным входом; файловые операции — временным каталогом теста. Обработчики удобно тестировать `httptest.NewRequest` и `ResponseRecorder`, отдельно проверяя статус, заголовки и тело.

Вопрос 24 из 25

Команда проверяет решение по теме «Тестирование и наблюдаемость». Что стоит проверить до переноса решения в общий компонент?

Проверка только текста ошибки может сломаться; причины следует распознавать через значения пакета `context` и `errors.Is`. Тест может пройти много раз при наличии гонки; отсутствие отчёта в одном запуске не является доказательством. Проверка `len(ch)==0` перед чтением не защищает от изменения состояния другой горутиной. Тест, который просто завершается после `recover`, может ложно пройти, если забыта проверка факта паники. Тест только успешного 200 не проверяет закрытие тела, медленные заголовки, разрыв соединения и повтор.

Вопрос 25 из 25

Перед публикацией кода по теме «Тестирование и наблюдаемость» нужно уточнить контракт. Как точнее всего описать пользу и цену этого решения?

Изолированный тест локализует дефект, а тест цепочки ловит ошибки порядка и взаимодействия слоёв. Логи паники нужны для расследования, но чувствительные данные из аргументов и стека следует фильтровать. Дополнительные метрики ожидания помогают найти конкуренцию, но сами измерения не заменяют корректный протокол блокировок. Детерминированная синхронизация лучше сна, но эксплуатационные метрики числа горутин всё равно нужны для накопительных утечек. Синтетические источники дают детерминизм, но интеграционный тест всё равно нужен для реального файла или соединения.