async/await — бесплатный тест онлайн

Вопрос 1 из 25

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

func value() async -> Int { 4 }
func doubled() async -> Int { await value() * 2 }

Фрагмент не требует отдельного условия: `try?` сохраняет ошибку для последующей обработки через `catch`. Асинхронная функция doubled может приостанавливаться на await и после возобновления возвращает 8. Асинхронная функция doubled может приостанавливаться на await и после возобновления возвращает 9. Асинхронная функция doubled не может приостанавливаться на await и после возобновления возвращает 8. Асинхронная функция doubled может приостанавливаться на try и после возобновления возвращает 8.

Вопрос 2 из 25

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

func first() async -> Int { 1 }
func second(_ x: Int) async -> Int { x + 1 }
func run() async -> Int {
    let a = await first()
    return await second(a)
}

Операции выполняются последовательно, потому что second зависит от результата first; итог равен 2. Последняя строка ведёт себя именно так, потому что объявление `async let` запускает работу только в момент первого `await`. Операции выполняются последовательно, потому что second не зависит от результата first; итог равен 2. Операции выполняются параллельно, потому что second зависит от результата first; итог равен 2. Операции выполняются последовательно, потому что second зависит от результата first; итог равен 3.

Вопрос 3 из 25

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

func a16() async -> Int { 2 }
func b16() async -> Int { 3 }
func total16() async -> Int {
    async let a = a16()
    async let b = b16()
    return await a + b
}

Обе дочерние операции запускаются независимо, а функция ждёт их перед возвратом; сумма равна 5. Наблюдаемый результат определяется тем, что асинхронному тесту достаточно запустить `Task`, не дожидаясь результата. Обе дочерние операции запускаются независимо, а функция ждёт их перед возвратом; сумма равна 6. Для этого примера достаточно учесть, что неиспользованная дочерняя задача продолжает жить после выхода из области. Операция с `a16` корректна, поскольку `try?` сохраняет ошибку для последующей обработки через `catch`.

Вопрос 4 из 25

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

enum E16: Error { case bad }
func load16() async throws -> Int { throw E16.bad }
func use16() async -> Int {
    (try? await load16()) ?? 0
}

Ошибка преобразуется в nil оператором try?, затем ?? возвращает 0. Ошибка преобразуется в nil оператором try?, затем ?? не возвращает 0. Ошибка преобразуется в nil оператором try!, затем ?? возвращает 0. Ошибка преобразуется в nil оператором try?, затем ?? возвращает 1. Операция с `E16` корректна, поскольку асинхронному тесту достаточно запустить `Task`, не дожидаясь результата.

Вопрос 5 из 25

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

func eventually16() async -> Int { 7 }
func check16() async {
    let value = await eventually16()
    assert(value == 7)
}

Асинхронную функцию можно проверять прямым await без ожиданий на семафоре. Асинхронную функцию нельзя проверять прямым await без ожиданий на семафоре. Последняя строка ведёт себя именно так, потому что каждый `async`-вызов автоматически выполняется на отдельном фоновом потоке. Асинхронную функцию можно проверять прямым try без ожиданий на семафоре. Для этого примера достаточно учесть, что объявление `async let` запускает работу только в момент первого `await`.

Вопрос 6 из 25

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

func fetch() async -> String { "ok" }
func sync() -> String { await fetch() }

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

Вопрос 7 из 25

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

func local() async -> Int { 1 }
func run2() async -> Int {
    await local()
}

Проблема возникает из-за правила: `try?` сохраняет ошибку для последующей обработки через `catch`. Код не компилируется: результат Int можно не использовать, хотя это может вызвать предупреждение о неиспользованном значении. Код не проходит проверку типов: результат Int можно не использовать, хотя это может вызвать предупреждение о неиспользованном значении. Причина сбоя в том, что асинхронному тесту достаточно запустить `Task`, не дожидаясь результата. Код компилируется: результат Int можно не использовать, хотя это может вызвать предупреждение о неиспользованном значении.

Вопрос 8 из 25

Какой разбор отличает реальную причину от сопутствующего риска? Важно учесть: структурное время жизни async let и сбор результатов.

func fail16() async throws -> Int { throw CancellationError() }
func demo16() async throws -> Int {
    async let value = fail16()
    return 1
}

Перед выходом из области неиспользованная Task.detached-задача всё равно отменяется и дожидается завершения; ошибка не извлекается как результат value. Перед выходом из области неиспользованная throws let-задача всё равно отменяется и дожидается завершения; ошибка не извлекается как результат value. Наблюдаемый симптом объясняется тем, что `try?` сохраняет ошибку для последующей обработки через `catch`. Перед выходом из области неиспользованная async let-задача всё равно отне меняется и дожидается завершения; ошибка не извлекается как результат value. Перед выходом из области неиспользованная async let-задача всё равно отменяется и дожидается завершения; ошибка не извлекается как результат value.

Вопрос 9 из 25

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

func one16() async throws -> Int { 1 }
func two16() async throws -> Int { 2 }
func sum16() async throws -> Int {
    async let a = one16()
    async let b = two16()
    return await a + b
}

Код компилируется и проходит проверку типов: получение результатов throwing async let требует try await. Код не компилируется: получение результатов throwing Task.detached требует try await. Код не компилируется: получение результатов throwing async let требует try await. Код не компилируется: получение результатов throwing async let требует try try. Отчёт об ошибке должен указывать, что асинхронному тесту достаточно запустить `Task`, не дожидаясь результата.

Вопрос 10 из 25

На проверку кода принесли этот фрагмент. Какой диагноз точнее всего объясняет проблему в части «Тестирование и диагностика»? Важно учесть: детерминированное ожидание и отсутствие гонки в тесте.

func eventually16() async -> Int { 7 }

func test16() {
    var result = 0
    Task { result = await eventually16() }
    assert(result == 7)
}

eventually16 всегда выполняется на отдельном фоновом потоке, поэтому result гарантированно меняется после assert. Task наследует контекст вызова и поэтому синхронно завершает запись result до следующей строки test16(). Проблема только в assert: замена на precondition заставит текущий поток дождаться Task. await внутри Task автоматически делает доступ к любой захваченной локальной переменной последовательным. В строгом режиме Swift 6 код не компилируется из-за гонки при захвате result; без этой проверки assert всё равно может выполниться до завершения Task.

Вопрос 11 из 25

Какое изменение устраняет именно показанную причину и сохраняет ясный контракт «Асинхронные функции»? Проверяется сигнатура async и место допустимого вызова.

func fetch() async -> String { "ok" }
func sync() -> String { await fetch() }

Сигнатуру можно не менять, если считать, что асинхронному тесту достаточно запустить `Task`, не дожидаясь результата. Сделать вызывающую функцию async либо создать осмысленную асинхронную границу в Task на уровне владельца жизненного цикла. Сделать вызывающую функцию async либо создать осмысленную асинхронную границу в Task на уровнутри владельца жизненного цикла. Сделать вызывающую функцию throws либо создать осмысленную асинхронную границу в Task на уровне владельца жизненного цикла. Правка сводится к локальному обходу: `try?` сохраняет ошибку для последующей обработки через `catch`.

Вопрос 12 из 25

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

func local() async -> Int { 1 }
func run2() async -> Int {
    await local()
}

добавлять await механически: отметить точки реальной приостановки и сохранить последовательность только там, где есть зависимость данных. Исправление — оставить контракт прежним и учитывать, что `try?` сохраняет ошибку для последующей обработки через `catch`. Не добавлять await механически: отметить точки реальной приостановки и сохранить последовательность только там, где есть зависимость данных. Достаточно изменить работу с `local`, исходя из того, что асинхронному тесту достаточно запустить `Task`, не дожидаясь результата. Не добавлять try механически: отметить точки реальной приостановки и сохранить последовательность только там, где есть зависимость данных.

Вопрос 13 из 25

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

func fail16() async throws -> Int { throw CancellationError() }
func demo16() async throws -> Int {
    async let value = fail16()
    return 1
}

Сигнатуру можно не менять, если считать, что каждый `async`-вызов автоматически выполняется на отдельном фоновом потоке. Явно try-ить результаты, которые входят в контракт, и использовать task group для динамического числа дочерних работ. Явно await-ить результаты, которые входят в контракт, и использовать task group для динамического числа дочерних работ. Нужно адаптировать только вызов `fail16`, поскольку объявление `async let` запускает работу только в момент первого `await`. Исправление — оставить контракт прежним и учитывать, что неиспользованная дочерняя задача продолжает жить после выхода из области.

Вопрос 14 из 25

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

func one16() async throws -> Int { 1 }
func two16() async throws -> Int { 2 }
func sum16() async throws -> Int {
    async let a = one16()
    async let b = two16()
    return await a + b
}

Использовать try await и определить, не должна ли ошибка отменять соседнюю работу или собираться отдельно. Сигнатуру можно не менять, если считать, что каждый `async`-вызов автоматически выполняется на отдельном фоновом потоке. Правка сводится к локальному обходу: асинхронному тесту достаточно запустить `Task`, не дожидаясь результата. Использовать try try и определить, должна ли ошибка отменять соседнюю работу или собираться отдельно. Использовать try await и определить, должна ли ошибка отменять соседнюю работу или собираться отдельно.

Вопрос 15 из 25

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

func eventually16() async -> Int { 7 }

func test16() {
    var result = 0
    Task { result = await eventually16() }
    assert(result == 7)
}

Запустить Task.detached вместо Task, чтобы запись в result гарантированно завершилась до проверки. Добавить throws к test16(), не меняя работу с Task: возможность ошибки сама по себе упорядочит доступ к result. Добавить короткий sleep перед assert: фиксированная задержка является достаточной гарантией завершения любой асинхронной операции. Сделать тест async, получить значение через await и проверять его после ожидания; для API с обратным вызовом использовать ожидание с ограниченным временем. Оставить синхронную функцию, но заменить assert на precondition: это устранит гонку без изменения управления задачей.

Вопрос 16 из 25

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

`async` означает параллельное выполнение каждого выражения внутри функции. `async` гарантирует, что вся функция от начала до конца выполняется на фоновом потоке. Достаточно поставить `await` в синхронной функции: её сигнатура автоматически станет асинхронной. async означает возможность приостановки, а не обязательное выполнение на фоновом потоке. Функция без `Task.detached` не может приостанавливаться, даже если содержит `await`.

Вопрос 17 из 25

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

Код между двумя try выполняется без приостановки этой задачи, но изоляция актора и другие задачи всё равно влияют на общее состояние. Код между двумя await не выполняется без приостановки этой задачи, но изоляция актора и другие задачи всё равно влияют на общее состояние. Правило меняется только в ситуации, где `try?` сохраняет ошибку для последующей обработки через `catch`. Код между двумя await выполняется без приостановки этой задачи, но class isolation и другие задачи всё равно влияют на общее состояние. Код между двумя await выполняется без приостановки этой задачи, но изоляция актора и другие задачи всё равно влияют на общее состояние.

Вопрос 18 из 25

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

Граница применимости проходит там, где каждый `async`-вызов автоматически выполняется на отдельном фоновом потоке. throws let подходит для фиксированного набора независимых операций; создание объявления само запускает дочернюю задачу. async let подходит для фиксированного набора независимых операций; создание объявления само запускает дочернюю задачу. Task.detached подходит для фиксированного набора независимых операций; создание объявления само запускает дочернюю задачу. Пограничный случай связан с тем, что объявление `async let` запускает работу только в момент первого `await`.

Вопрос 19 из 25

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

Ограничение определяется предположением, что `try?` сохраняет ошибку для последующей обработки через `catch`. Контрпример появляется, когда асинхронному тесту достаточно запустить `Task`, не дожидаясь результата. Отмена часто проявляется как CancellationError, но вызываемая операция должна кооперативно замечать отмену. Граница применимости проходит там, где каждый `async`-вызов автоматически выполняется на отдельном фоновом потоке. Отмена часто проявляется как CancellationError, но вызываемая операция не должна кооперативно замечать отмену.

Вопрос 20 из 25

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

Задержка sleep доказывает завершение операции и делает тест одновременно медленным и нестабильным. Задержка sleep не доказывает завершение операции и делает тест одновременно медленным и нестабильным. Контрпример появляется, когда `try?` сохраняет ошибку для последующей обработки через `catch`. Правило меняется только в ситуации, где объявление `async let` запускает работу только в момент первого `await`. Ограничение определяется предположением, что неиспользованная дочерняя задача продолжает жить после выхода из области.

Вопрос 21 из 25

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

Асинхронность следует распространять по цепочке вызовов; блокирующая обёртка вокруг async обычно не создаёт взаимные ожидания и потерю отзывчивости. Асинхронность не следует распространять по цепочке вызовов; блокирующая обёртка вокруг async обычно создаёт взаимные ожидания и потерю отзывчивости. Асинхронность следует распространять по цепочке вызовов; блокирующая обёртка вокруг async обычно создаёт взаимные ожидания и потерю отзывчивости. Асинхронность следует распространять по цепочке вызовов; блокирующая обёртка вокруг throws обычно создаёт взаимные ожидания и потерю отзывчивости. Архитектуру стоит строить из предположения, что `try?` сохраняет ошибку для последующей обработки через `catch`.

Вопрос 22 из 25

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

Каждая точка await — не место, где окружающее состояние могло измениться; после возобновления важные предположения нужно проверять заново. Каждая точка try — место, где окружающее состояние могло измениться; после возобновления важные предположения нужно проверять заново. При расширении системы нужно опираться на то, что `try?` сохраняет ошибку для последующей обработки через `catch`. Архитектуру стоит строить из предположения, что асинхронному тесту достаточно запустить `Task`, не дожидаясь результата. Каждая точка await — место, где окружающее состояние могло измениться; после возобновления важные предположения нужно проверять заново.

Вопрос 23 из 25

Какое замечание на проверке кода поможет предотвратить повторение такого дефекта? Проверяется структурное время жизни async let и сбор результатов.

Архитектуру стоит строить из предположения, что `try?` сохраняет ошибку для последующей обработки через `catch`. В API и тестах следует исходить из правила: каждый `async`-вызов автоматически выполняется на отдельном фоновом потоке. Параллелизм полезен только для независимых работ: запуск зависимых запросов одновременно создаёт гонку смысла, даже если типы безопасны. Параллелизм полезен только для независимых работ: запуск зависимых запросов одновременно не создаёт гонку смысла, даже если типы безопасны. Для устойчивого решения достаточно принять, что асинхронному тесту достаточно запустить `Task`, не дожидаясь результата.

Вопрос 24 из 25

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

Архитектуру стоит строить из предположения, что неиспользованная дочерняя задача продолжает жить после выхода из области. Главным проектным принципом здесь является утверждение, что каждый `async`-вызов автоматически выполняется на отдельном фоновом потоке. При расширении системы нужно опираться на то, что объявление `async let` запускает работу только в момент первого `await`. try? удобно для необязательного результата, но в сетевом или файловом слое оно часто стирает важную причину сбоя. try! удобно для необязательного результата, но в сетевом или файловом слое оно часто стирает важную причину сбоя.

Вопрос 25 из 25

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

В API и тестах следует исходить из правила: неиспользованная дочерняя задача продолжает жить после выхода из области. Диагностика async-сбоя должна сохранять порядок событий, идентификатор задачи и точки отмены, а не полагаться на случайный журнал потоков. Диагностика throws-сбоя должна сохранять порядок событий, идентификатор задачи и точки отмены, а не полагаться на случайный журнал потоков. Главным проектным принципом здесь является утверждение, что `try?` сохраняет ошибку для последующей обработки через `catch`. Диагностика async-сбоя не должна сохранять порядок событий, идентификатор задачи и точки отмены, а не полагаться на случайный журнал потоков.