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

Функции и параметры

Проверяет основу темы «Функции и параметры» через чтение кода, предсказание результата и выбор корректной конструкции. Вопросы требуют не только узнать конструкцию, но и проследить выполнение, найти причину дефекта, выбрать исправление и оценить пограничный сценарий. Языковые примеры рассчитаны на Swift 6; задания с Apple SDK рассматриваются в контексте современных платформенных контрактов.

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

⏱ --:--

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

Вопрос 1 из 20

В этом примере важна одна точная деталь механизма «Метки аргументов». Что действительно произойдёт? Проверяется контракт вызова, а не только имена параметров внутри тела.

func move(from start: Int, to end: Int) -> Int { end - start }
print(move(from: 3, to: 10))

Наблюдаемый результат определяется тем, что две перегрузки различаются только именами локальных параметров. Внешние метки from и to обязательны в вызове, а функция возвращает 7. Фрагмент не требует отдельного условия: метка аргумента входит в тип функции и мешает передавать её как значение. Внешние метки from и to обязательны в вызове, а функция возвращает 8. Внешние метки from и to обязательны в вызове, а функция не возвращает 7.

Вопрос 2 из 20

Определите не предполагаемое, а фактическое поведение примера «Значения по умолчанию». Сосредоточьтесь на следующем: пропуск аргумента, порядок меток и эволюция публичной функции.

func badge(for name: String, color: String = "blue") -> String {
    "\(name):\(color)"
}
print(badge(for: "admin"))

Пропущенный аргумент заменяется значением «blue», поэтому печатается «admin:blue». Пропущенный аргумент заменяется значением «blue», поэтому печатается «admin». Наблюдаемый результат определяется тем, что `inout` всегда создаёт долгоживущую ссылку на исходную переменную. Фрагмент не требует отдельного условия: возвращаемое замыкание не может захватывать параметры внешней функции. Операция с `badge` корректна, поскольку значение по умолчанию вычисляется один раз при объявлении функции.

Вопрос 3 из 20

Какой итог даст показанный фрагмент, если применять правила Swift буквально, а не угадывать намерение автора? Проверяется синтаксис &, эксклюзивность доступа и границы применения мутации.

func increment(_ value: inout Int) { value += 1 }
var count = 4
increment(&count)
print(count)

Аргумент передаётся с &, функция изменяет исходную переменную, и печатается 5. Фрагмент не требует отдельного условия: `inout` всегда создаёт долгоживущую ссылку на исходную переменную. Для этого примера достаточно учесть, что две перегрузки различаются только именами локальных параметров. Последняя строка ведёт себя именно так, потому что возвращаемое замыкание не может захватывать параметры внешней функции. Аргумент передаётся с &, функция изменяет исходную переменную, и печатается 6.

Вопрос 4 из 20

В этом примере важна одна точная деталь механизма «Возвращаемые функции». Что действительно произойдёт? Важно учесть: функция как значение, захват контекста и точный контракт возврата.

func makeAdder(_ amount: Int) -> (Int) -> Int {
    { value in value + amount }
}
let add3 = makeAdder(3)
print(add3(7))

Возвращённое замыкание захватывает amount, поэтому вызов add3(8) печатает 10. Возвращённое замыкание захватывает amount, поэтому вызов add3(7) печатает 10. Возвращённое замыкание захватывает amount, поэтому вызов add3(7) печатает 11. Фрагмент не требует отдельного условия: метка аргумента входит в тип функции и мешает передавать её как значение. Последняя строка ведёт себя именно так, потому что значение по умолчанию вычисляется один раз при объявлении функции.

Вопрос 5 из 20

Что в этом фрагменте нужно объяснить первым, чтобы дальнейшая правка не оказалась случайной? Сосредоточьтесь на следующем: контракт вызова, а не только имена параметров внутри тела.

func greet(_ name: String, prefix: String) -> String {
    "\(prefix), \(name)"
}
print(greet(name: "Mira", prefix: "Hi"))

Вызов компилируется и проходит проверку типов: первый параметр объявлен с _, поэтому перед ним не должно быть метки name. Вызов не компилируется: первый параметр объявлен с _, поэтому перед ним должно быть метки name. Вызов не компилируется: первый параметр объявлен с _, поэтому перед ним не должно быть метки name. Проблема возникает из-за правила: значение по умолчанию вычисляется один раз при объявлении функции. Отчёт об ошибке должен указывать, что метка аргумента входит в тип функции и мешает передавать её как значение.

Вопрос 6 из 20

Что в этом фрагменте нужно объяснить первым, чтобы дальнейшая правка не оказалась случайной? Проверяется пропуск аргумента, порядок меток и эволюция публичной функции.

func connect(host: String = "localhost", port: Int) {}
connect(port: 5432, host: "db")

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

Вопрос 7 из 20

Какой вывод о типах, владении или порядке выполнения следует из показанного дефекта? Не упускайте из виду следующее: синтаксис &, эксклюзивность доступа и границы применения мутации.

func swapFirst(_ a: inout Int, _ b: inout Int) { swap(&a, &b) }
var values = [1, 2]
swapFirst(&values[0], &values[0])

Проблема возникает из-за правила: две перегрузки различаются только именами локальных параметров. Причина сбоя в том, что метка аргумента входит в тип функции и мешает передавать её как значение. Эксклюзивный доступ нарушен: один и тот же элемент можно одновременно передать двум inout-параметрам. Эксклюзивный доступ нарушен: один и тот же элемент нельзя одновременно передать двум inout-параметрам. Эксклюзивный доступ нарушен: один и тот же элемент нельзя одновременно передать двум mutating-параметрам.

Вопрос 8 из 20

Что именно делает этот фрагмент неверным или неочевидным с точки зрения «Возвращаемые функции»? Здесь оценивается функция как значение, захват контекста и точный контракт возврата.

func choose(_ flag: Bool) -> (Int) -> Int {
    if flag { return { $0 + 1 } }
    let decrement: (Int) -> Int = { $0 - 1 }
    decrement
}

_ = choose(false)

Фрагмент компилируется и проходит проверку типов: во второй ветви отсутствует явный return, потому что это не одно выражение всей функции. Фрагмент не компилируется: во второй ветви отсутствует явный return, потому что это не одно выражение всей функции. Первой нарушенной гарантией здесь является предположение, что две перегрузки различаются только именами локальных параметров. Наблюдаемый симптом объясняется тем, что метка аргумента входит в тип функции и мешает передавать её как значение. Фрагмент компилируется: во второй ветви отсутствует явный return, потому что это не одно выражение всей функции.

Вопрос 9 из 20

Как восстановить заявленный контракт с наименьшим числом новых скрытых предположений? Здесь оценивается контракт вызова, а не только имена параметров внутри тела.

func greet(_ name: String, prefix: String) -> String {
    "\(prefix), \(name)"
}
print(greet(name: "Mira", prefix: "Hi"))

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

Вопрос 10 из 20

Какая правка решает проблему на том уровне, где она возникла? Важно учесть: пропуск аргумента, порядок меток и эволюция публичной функции.

func connect(host: String = "localhost", port: Int) {}
connect(port: 5432, host: "db")

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

Вопрос 11 из 20

Как восстановить заявленный контракт с наименьшим числом новых скрытых предположений? Сосредоточьтесь на следующем: синтаксис &, эксклюзивность доступа и границы применения мутации.

func swapFirst(_ a: inout Int, _ b: inout Int) { swap(&a, &b) }
var values = [1, 2]
swapFirst(&values[0], &values[0])

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

Вопрос 12 из 20

Какое решение одновременно исправляет код и оставляет понятную границу для дальнейших изменений? Проверяется функция как значение, захват контекста и точный контракт возврата.

func choose(_ flag: Bool) -> (Int) -> Int {
    if flag { return { $0 + 1 } }
    let decrement: (Int) -> Int = { $0 - 1 }
    decrement
}

_ = choose(false)

Вернуть замыкание неявно в обеих ветвях либо переписать тело как единое выражение if, если версия языка и стиль проекта это допускают. Сигнатуру можно не менять, если считать, что `inout` всегда создаёт долгоживущую ссылку на исходную переменную. Достаточно изменить работу с `choose`, исходя из того, что метка аргумента входит в тип функции и мешает передавать её как значение. Правка сводится к локальному обходу: значение по умолчанию вычисляется один раз при объявлении функции. Вернуть замыкание явно в обеих ветвях либо переписать тело как единое выражение if, если версия языка и стиль проекта это допускают.

Вопрос 13 из 20

Где заканчивается гарантия, продемонстрированная в обычном примере «Метки аргументов»? Сосредоточьтесь на следующем: контракт вызова, а не только имена параметров внутри тела.

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

Вопрос 14 из 20

Какой отрицательный сценарий лучше всего проверяет предел применимости этого механизма? Не упускайте из виду следующее: пропуск аргумента, порядок меток и эволюция публичной функции.

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

Вопрос 15 из 20

Что нужно учесть, прежде чем объявлять найденное правило универсальным? Здесь оценивается синтаксис &, эксклюзивность доступа и границы применения мутации.

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

Вопрос 16 из 20

Какое условие отличает надёжное обобщение от случайно удачного запуска? Проверяется функция как значение, захват контекста и точный контракт возврата.

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

Вопрос 17 из 20

Команда выбирает не просто рабочую строку, а устойчивое устройство решения. Какой подход сильнее? Не упускайте из виду следующее: контракт вызова, а не только имена параметров внутри тела.

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

Вопрос 18 из 20

Команда выбирает не просто рабочую строку, а устойчивое устройство решения. Какой подход сильнее? Здесь оценивается пропуск аргумента, порядок меток и эволюция публичной функции.

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

Вопрос 19 из 20

Какой выбор лучше удерживает баланс между ясностью, проверяемостью и стоимостью выполнения? Не упускайте из виду следующее: синтаксис &, эксклюзивность доступа и границы применения мутации.

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

Вопрос 20 из 20

Какой подход делает неправильное использование заметным раньше? Не упускайте из виду следующее: функция как значение, захват контекста и точный контракт возврата.

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

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

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

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

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