GO Go · 20 вопросов · ~55 мин · ⏱ Таймер 55:00 · Лёгкий ·

Функции и несколько возвращаемых значений

Проверяет передачу аргументов, несколько результатов, вариативные параметры и осторожное использование именованных возвращаемых значений. В тесте 20 вопросов, из них 12 требуют чтения кода, команд или диагностических фрагментов. Задания опираются на устойчивые правила современного Go; если поведение зависит от версии, это оговорено в самом вопросе.

Отвечено: 0 из 20

⏱ --:--

💡 Инструкция: Выберите один ответ из пяти. На 20 вопросов отведено 55 минут. В каждом вопросе верен только один вариант. После завершения вы увидите общий результат и результаты по 4 тематическим шкалам с объяснениями и практическими рекомендациями.

Вопрос 1 из 20

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

// Фрагмент для трассировки.
package main
import "fmt"
func touch(xs []int) { xs[0] = 9; xs = append(xs, 10) }
func main() {
    xs := []int{1, 2}
    touch(xs)
    fmt.Println(xs)
}

После `b := a` поле-срез в обеих структурах указывает на один массив, поэтому изменение элемента видно через обе копии. После ускорения CPU функция исчезает из профиля, но p99 не меняется, если запрос ждёт базу. Тест проверяет и значение, и `ok`, поэтому не путает нулевой элемент с закрытым каналом. Каждая горутина получает собственное значение `v`, поэтому не читает одну меняющуюся переменную цикла. Функция меняет первый элемент исходного среза, хотя сама переменная-срез внутри функции передана по значению.

Вопрос 2 из 20

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

// Фрагмент из ревью: требуется выбрать безопасную правку.
package main
import "fmt"
func touch(xs []int) { xs[0] = 9; xs = append(xs, 10) }
func main() {
    xs := []int{1, 2}
    touch(xs)
    fmt.Println(xs)
}

Документировать мутацию входного среза или принимать копию, если функция обещает не менять данные вызывающего кода. Создавать локальную копию данных случая там, где версия языка или форма цикла допускает захват изменяемой переменной. Хранить репрезентативные старые документы в `testdata`, проверять ограничения размера и не журналировать полный чувствительный JSON. Хранить примеры компилируемыми, тестировать нулевое значение и конкурентный контракт, если они обещаны. Копировать данные через `copy` или `append([]T(nil), src...)`, когда нужен независимый снимок.

Вопрос 3 из 20

Фрагмент относится к теме «Параметры». Какое правило Go непосредственно объясняет поведение фрагмента?

// Определите правило Go, которое объясняет результат.
package main
import "fmt"
func touch(xs []int) { xs[0] = 9; xs = append(xs, 10) }
func main() {
    xs := []int{1, 2}
    touch(xs)
    fmt.Println(xs)
}

Правильное исправление устраняет общий доступ или синхронизирует его; копирование переменной цикла может убрать захват одного изменяемого значения. Аргументы передаются по значению; для среза копируется заголовок, который всё ещё указывает на общий массив. Интерфейс определяет потребитель; часто достаточно одного метода, который функция действительно вызывает. Закрытие сообщает, что новых значений больше не будет; обычно канал закрывает отправитель, который знает о завершении всех отправок. `http.Handler` получает `ResponseWriter` и `Request`; заголовок статуса следует записать до тела.

Вопрос 4 из 20

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

Один общий короткий таймаут может оборвать законное потоковое тело после успешных заголовков. Изменение `GOMAXPROCS` может менять частоту проявления, но отсутствие сбоя при одном значении ничего не доказывает. Тест только успешного 200 не проверяет закрытие тела, медленные заголовки, разрыв соединения и повтор. Маленький подсрез способен удерживать в памяти большой базовый массив. Переназначение параметра-среза на новый срез не меняет заголовок среза у вызывающего кода.

Вопрос 5 из 20

В разделе «Параметры» показан конкретный случай. Когда этот приём помогает, а когда начинает мешать?

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

Вопрос 6 из 20

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

// Фрагмент для трассировки.
package main
import "strconv"
func parse() (int, error) { return strconv.Atoi("7") }
func main() { n, err := parse(); _, _ = n, err }

Присваивание `const x = 1 << 40` переменной `int64` корректно; присваивание `int32` не скомпилируется. Отложенная функция получает значение `"boom"`, и программа продолжает выполнение после завершения функции `run`. Функция возвращает `7, nil`; запись `n, err := parse()` корректно получает оба результата. Для ошибки, обёрнутой через `%w`, `errors.Is(err, ErrMissing)` возвращает `true`. Функция возвращает ненулевую ошибку при отрицательном входе, а вызывающий код может обработать её без паники.

Вопрос 7 из 20

Фрагмент относится к теме «Возврат значений». Какое изменение лучше всего укрепит контракт этого фрагмента?

// Фрагмент из ревью: требуется выбрать безопасную правку.
package main
import "strconv"
func parse() (int, error) { return strconv.Atoi("7") }
func main() { n, err := parse(); _, _ = n, err }

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

Вопрос 8 из 20

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

// Определите правило Go, которое объясняет результат.
package main
import "strconv"
func parse() (int, error) { return strconv.Atoi("7") }
func main() { n, err := parse(); _, _ = n, err }

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

Вопрос 9 из 20

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

Только один операнд `%w` обычно соответствует одной оборачиваемой ошибке; форматирование `%v` не создаёт цепочку. Нельзя использовать многозначный вызов как один аргумент рядом с другими аргументами, если сигнатура не допускает точного разворачивания. Размер `int` зависит от разрядности целевой платформы, поэтому его нельзя молча считать всегда 64-битным. Вызов `recover()` вне выполняемого `defer` возвращает `nil` и ничего не перехватывает. В цикле отложенные вызовы выполнятся только при выходе из окружающей функции, что может слишком долго удерживать ресурсы.

Вопрос 10 из 20

Команда проверяет решение по теме «Возврат значений». Как решение влияет на читаемость и надёжность?

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

Вопрос 11 из 20

Фрагмент относится к теме «Вариативные параметры». Что увидит вызывающий код после выполнения?

// Фрагмент для трассировки.
package main
func sum(xs ...int) int { n := 0; for _, x := range xs { n += x }; return n }
func main() { xs := []int{1,2,3}; _ = sum(xs...) }

Код печатает `0 false ""`, потому что переменные объявлены, но им ничего не присвоено. Функция возвращает ненулевую ошибку при отрицательном входе, а вызывающий код может обработать её без паники. Для ошибки, обёрнутой через `%w`, `errors.Is(err, ErrMissing)` возвращает `true`. Внешний `defer` в `main` не восстановит панику, запущенную внутри отдельной горутины. Вызов `sum(xs...)` передаёт элементы `xs` как отдельные аргументы и возвращает `6`.

Вопрос 12 из 20

На ревью разбирают тему «Вариативные параметры». Как подготовить этот код к реальному использованию?

// Фрагмент из ревью: требуется выбрать безопасную правку.
package main
func sum(xs ...int) int { n := 0; for _, x := range xs { n += x }; return n }
func main() { xs := []int{1,2,3}; _ = sum(xs...) }

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

Вопрос 13 из 20

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

// Определите правило Go, которое объясняет результат.
package main
func sum(xs ...int) int { n := 0; for _, x := range xs { n += x }; return n }
func main() { xs := []int{1,2,3}; _ = sum(xs...) }

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

Вопрос 14 из 20

Команда проверяет решение по теме «Вариативные параметры». Какое допущение здесь чаще всего оказывается ложным?

После восстановления нельзя автоматически считать частично изменённые данные согласованными. `defer` не выполняется при `os.Exit`, поэтому такой выход нельзя считать обычным завершением функции. `iota` сбрасывается в каждом новом блоке `const`, а не продолжает глобальную последовательность. После обычных аргументов вариативный параметр должен быть последним в сигнатуре. Сравнение текстов ошибок ненадёжно: сообщение может измениться, быть локализовано или содержать контекст.

Вопрос 15 из 20

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

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

Вопрос 16 из 20

На ревью разбирают тему «Именованные результаты». Что гарантированно произойдёт в показанной последовательности операций?

// Фрагмент для трассировки.
package main
func answer() (n int) {
    defer func(){ n++ }()
    n = 1
    return
}
func main(){ _ = answer() }

Функция возвращает ненулевую ошибку при отрицательном входе, а вызывающий код может обработать её без паники. Перед завершением программы отложенный `fmt.Println("cleanup")` выполнится, а затем будет напечатана трассировка паники. Для ошибки, обёрнутой через `%w`, `errors.Is(err, ErrMissing)` возвращает `true`. Отложенная функция получает значение `"boom"`, и программа продолжает выполнение после завершения функции `run`. Отложенная функция увеличивает именованный результат, поэтому `answer()` возвращает `2`, а не `1`.

Вопрос 17 из 20

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

// Фрагмент из ревью: требуется выбрать безопасную правку.
package main
func answer() (n int) {
    defer func(){ n++ }()
    n = 1
    return
}
func main(){ _ = answer() }

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

Вопрос 18 из 20

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

// Определите правило Go, которое объясняет результат.
package main
func answer() (n int) {
    defer func(){ n++ }()
    n = 1
    return
}
func main(){ _ = answer() }

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

Вопрос 19 из 20

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

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

Вопрос 20 из 20

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

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

Ответьте на все 20 вопросов, чтобы получить результат

🔗 Встроить тест на свой сайт (iframe) ▼

Скопируйте код и вставьте в любое место на вашем сайте:

Также доступна прямая ссылка на embed-страницу