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

Замыкания

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

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

⏱ --:--

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

Вопрос 1 из 20

Что увидит разработчик после выполнения этого примера по теме «Синтаксис»? Сосредоточьтесь на следующем: вывод сигнатуры и границы сокращённой записи.

let values = [3, 1, 2]
let sorted = values.sorted { $0 < $1 }
print(sorted)

Сокращённые имена параметров задают возрастающее сравнение, поэтому печатается [2, 2, 3]. Сокращённые имена параметров задают возрастающее сравнение, поэтому печатается [1, 2, 3]. Последняя строка ведёт себя именно так, потому что сокращённые имена аргументов меняют порядок вычисления выражения. Сокращённые имена параметров задают возрастающее сравнение, поэтому печатается [1, 3, 3]. Сокращённые имена параметров задают возрастающее сравнение, поэтому печатается [1, 2, 4].

Вопрос 2 из 20

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

var total = 0
let add = { total += 1; return total }
print(add(), add())

Замыкание захватывает переменную по ссылочной коробке состояния; последовательные вызовы печатают 1 и 3. Фрагмент не требует отдельного условия: сокращённые имена аргументов меняют порядок вычисления выражения. Замыкание захватывает переменную по ссылочной коробке состояния; последовательные вызовы печатают 2 и 2. Наблюдаемый результат определяется тем, что `@autoclosure` автоматически делает замыкание `@escaping`. Замыкание захватывает переменную по ссылочной коробке состояния; последовательные вызовы печатают 1 и 2.

Вопрос 3 из 20

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

func runEscapingExample() {
    var jobs: [() -> Void] = []
    func schedule(_ job: @escaping () -> Void) {
        jobs.append(job)
    }
    schedule { print("later") }
    jobs[0]()
}

runEscapingExample()

Аннотация @autoclosure разрешает сохранить замыкание после возврата функции; затем печатается «later». Аннотация @escaping разрешает сохранить замыкание после возврата функции; затем печатается «later». Аннотация @escaping разрешает сохранить замыкание после возврата функции; затем печатается «nil». Для этого примера достаточно учесть, что `@autoclosure` автоматически делает замыкание `@escaping`. Операция с `runEscapingExample` корректна, поскольку сокращённые имена аргументов меняют порядок вычисления выражения.

Вопрос 4 из 20

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

var value = 1
let show = { [value] in print(value) }
value = 9
show()

Capture list сохраняет снимок value при создании замыкания, поэтому печатается 1. Операция с `value` корректна, поскольку список захвата вычисляется заново при каждом вызове замыкания. Capture list не сохраняет снимок value при создании замыкания, поэтому печатается 1. Для этого примера достаточно учесть, что неэкранирующее замыкание можно сохранить в свойстве без изменения сигнатуры. Capture list сохраняет снимок value при создании замыкания, поэтому печатается 2.

Вопрос 5 из 20

Почему этот код не выполняет заявленный контракт? Проверяется вывод сигнатуры и границы сокращённой записи.

func apply(_ transform: (Int, Int) -> Int) -> Int { transform(2, 3) }
let result = apply { $0 + $2 }

Проблема возникает из-за правила: сокращённые имена аргументов меняют порядок вычисления выражения. Код компилируется: у замыкания только два параметра, поэтому $2 не существует. Код не компилируется: у замыкания только два параметра, поэтому $2 не существует. Код компилируется и проходит проверку типов: у замыкания только два параметра, поэтому $2 не существует. Код не компилируется: у замыкания только два параметра, поэтому $3 не существует.

Вопрос 6 из 20

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

var handlers: [() -> Void] = []
for i in 0..<3 {
    handlers.append { print(i) }
}
handlers.forEach { $0() }

В современном Swift каждая итерация for создаёт своё значение i, поэтому печатаются 0, 1 и 3. Наблюдаемый симптом объясняется тем, что список захвата вычисляется заново при каждом вызове замыкания. В современном Swift каждая итерация for создаёт своё значение i, поэтому печатаются 0, 1 и 2. В современном Swift каждая итерация for создаёт своё значение i, поэтому печатаются 0, 2 и 2. В современном Swift каждая итерация for создаёт своё значение i, поэтому печатаются 1, 1 и 2.

Вопрос 7 из 20

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

func store(_ action: () -> Void) -> () -> Void {
    action
}

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

Вопрос 8 из 20

Разработчик видит симптом, но ищет первопричину. Какое объяснение выдерживает проверку кодом? Важно учесть: снимок значения и предотвращение циклов удержания.

final class Controller {
    var callback: (() -> Void)?
    func install() {
        callback = { print(self) }
    }
}

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

Вопрос 9 из 20

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

func apply(_ transform: (Int, Int) -> Int) -> Int { transform(2, 3) }
let result = apply { $0 + $2 }

Нужно адаптировать только вызов `apply`, поскольку `@autoclosure` автоматически делает замыкание `@escaping`. Использовать $0 и $2 либо дать параметрам явные имена, если выражение перестаёт читаться с первого взгляда. Использовать $0 и $1 либо дать параметрам явные имена, если выражение перестаёт читаться с первого взгляда. Сигнатуру можно не менять, если считать, что замыкание захватывает локальные значения только по слабой ссылке. Использовать $1 и $1 либо дать параметрам явные имена, если выражение перестаёт читаться с первого взгляда.

Вопрос 10 из 20

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

var handlers: [() -> Void] = []
for i in 0..<3 {
    handlers.append { print(i) }
}
handlers.forEach { $0() }

Достаточно изменить работу с `handlers`, исходя из того, что неэкранирующее замыкание можно сохранить в свойстве без изменения сигнатуры. Нужно адаптировать только вызов `handlers`, поскольку `@autoclosure` автоматически делает замыкание `@escaping`. переносить автоматически интуицию о позднем связывании из других языков; проверять конкретные правила области видимости Swift. Исправление — оставить контракт прежним и учитывать, что сокращённые имена аргументов меняют порядок вычисления выражения. Не переносить автоматически интуицию о позднем связывании из других языков; проверять конкретные правила области видимости Swift.

Вопрос 11 из 20

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

func store(_ action: () -> Void) -> () -> Void {
    action
}

Пометить параметр @escaping, если сохранение или возврат действительно часть контракта. Исправление — оставить контракт прежним и учитывать, что сокращённые имена аргументов меняют порядок вычисления выражения. Достаточно изменить работу с `store`, исходя из того, что неэкранирующее замыкание можно сохранить в свойстве без изменения сигнатуры. Пометить параметр @autoclosure, если сохранение или возврат действительно часть контракта. Нужно адаптировать только вызов `store`, поскольку `@autoclosure` автоматически делает замыкание `@escaping`.

Вопрос 12 из 20

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

final class Controller {
    var callback: (() -> Void)?
    func install() {
        callback = { print(self) }
    }
}

Достаточно изменить работу с `Controller`, исходя из того, что неэкранирующее замыкание можно сохранить в свойстве без изменения сигнатуры. Использовать [weak self] и безопасно обработать nil, если замыкание хранится объектом и должно продлевать его жизнь. Использовать [weak self] и безопасно обработать nil, если замыкание хранится объектом и не должно продлевать его жизнь. Использовать [unowned self] и безопасно обработать nil, если замыкание хранится объектом и не должно продлевать его жизнь. Исправление — оставить контракт прежним и учитывать, что сокращённые имена аргументов меняют порядок вычисления выражения.

Вопрос 13 из 20

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

Пограничный случай связан с тем, что `@autoclosure` автоматически делает замыкание `@escaping`. Trailing closure нельзя вынести за скобки, а при нескольких замыканиях метки последующих всё равно участвуют в вызове. Правило меняется только в ситуации, где сокращённые имена аргументов меняют порядок вычисления выражения. Trailing closure можно вынести за скобки, а при нескольких замыканиях метки последующих всё равно участвуют в вызове. Граница применимости проходит там, где замыкание захватывает локальные значения только по слабой ссылке.

Вопрос 14 из 20

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

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

Вопрос 15 из 20

На какой границе входов, владения или времени жизни результат может стать другим? Важно учесть: момент выхода замыкания за время жизни вызова.

Nonэкранирующее замыкание нельзя оптимизировать и оно не требует явного self в тех же ситуациях, где escaping требует. Граница применимости проходит там, где неэкранирующее замыкание можно сохранить в свойстве без изменения сигнатуры. Nonэкранирующее замыкание можно оптимизировать и оно не требует явного self в тех же ситуациях, где escaping требует. Пограничный случай связан с тем, что список захвата вычисляется заново при каждом вызове замыкания. Nonэкранирующее замыкание можно оптимизировать и оно требует явного self в тех же ситуациях, где escaping требует.

Вопрос 16 из 20

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

unowned подходит только когда время жизни self гарантированно длиннее замыкания; нарушение гарантии не приводит к аварии. Граница применимости проходит там, где список захвата вычисляется заново при каждом вызове замыкания. Контрпример появляется, когда неэкранирующее замыкание можно сохранить в свойстве без изменения сигнатуры. weak подходит только когда время жизни self гарантированно длиннее замыкания; нарушение гарантии приводит к аварии. unowned подходит только когда время жизни self гарантированно длиннее замыкания; нарушение гарантии приводит к аварии.

Вопрос 17 из 20

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

Сокращённый синтаксис хорош для короткой очевидной операции; сложная логика выигрывает от имён параметров и отдельной функции. Для устойчивого решения достаточно принять, что сокращённые имена аргументов меняют порядок вычисления выражения. При расширении системы нужно опираться на то, что замыкание захватывает локальные значения только по слабой ссылке. Архитектуру стоит строить из предположения, что `@autoclosure` автоматически делает замыкание `@escaping`. В API и тестах следует исходить из правила: неэкранирующее замыкание можно сохранить в свойстве без изменения сигнатуры.

Вопрос 18 из 20

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

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

Вопрос 19 из 20

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

следует ставить @escaping «на всякий случай»: аннотация расширяет время жизни захватов и риск цикла удержания. Не следует ставить @autoclosure «на всякий случай»: аннотация расширяет время жизни захватов и риск цикла удержания. При расширении системы нужно опираться на то, что `@autoclosure` автоматически делает замыкание `@escaping`. Главным проектным принципом здесь является утверждение, что замыкание захватывает локальные значения только по слабой ссылке. Не следует ставить @escaping «на всякий случай»: аннотация расширяет время жизни захватов и риск цикла удержания.

Вопрос 20 из 20

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

Capture list — явная модель владения: weak не всегда лучше strong, выбор не зависит от того, должен ли обратный вызов удерживать владельца. Capture list — явная модель владения: weak не всегда лучше strong, выбор зависит от того, должен ли обратный вызов удерживать владельца. Capture list — явная модель владения: unowned не всегда лучше strong, выбор зависит от того, должен ли обратный вызов удерживать владельца. В API и тестах следует исходить из правила: сокращённые имена аргументов меняют порядок вычисления выражения. Capture list — явная модель владения: weak не всегда лучше strong, выбор зависит от того, не должен ли обратный вызов удерживать владельца.

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

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

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

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