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," ") } }

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

Вопрос 3 из 25

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

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

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

Вопрос 4 из 25

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

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

Вопрос 5 из 25

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

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

Вопрос 6 из 25

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

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

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

Вопрос 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 не выполняет неявное числовое преобразование между именованными типами; преобразование пишется явно. `panic` прекращает обычное выполнение текущей горутины и запускает раскрутку стека с выполнением `defer`. `errors.Is` проходит цепочку обёрток и учитывает методы `Is`; обычное `==` видит только непосредственно сравнимое значение. Ошибка — значение, обычно возвращаемое отдельным результатом; `errors.New` подходит для постоянного сообщения без форматирования.

Вопрос 9 из 25

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

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

Вопрос 10 из 25

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

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

Вопрос 11 из 25

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

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

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

Вопрос 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` и ничего не перехватывает. Голый `return` в длинной функции усложняет понимание, какое значение фактически возвращается. `fallthrough` переходит в следующую ветвь без проверки её выражения. Преобразование целого к меньшему типу отбрасывает старшие биты и не сообщает о переполнении.

Вопрос 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
}

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

Вопрос 17 из 25

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

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

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

Вопрос 18 из 25

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

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

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

Вопрос 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")
}

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

Вопрос 24 из 25

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

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

Вопрос 25 из 25

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

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