SW Swift · 25 вопросов · ~70 мин · ⏱ Таймер 10:00 · Средний ·

Optional chaining и функциональные преобразования

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

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

⏱ --:--

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

Вопрос 1 из 25

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

let text: String? = "swift"
let length = text.map(\.count)
print(length as Any)

flatMap применяет преобразование к существующему значению и возвращает Optional с 5. map применяет преобразование к существующему значению и возвращает Result с 5. map применяет преобразование к существующему значению и возвращает Optional с 6. map применяет преобразование к существующему значению и возвращает Optional с 5. Для этого примера достаточно учесть, что `map` и `flatMap` всегда возвращают Optional одинаковой вложенности.

Вопрос 2 из 25

Что увидит разработчик после выполнения этого примера по теме «Преобразование через flatMap»? Проверяется выравнивание Optional и условное выполнение.

let raw: String? = "120"
let number = raw.flatMap(Int.init)
print(number as Any)

flatMap объединяет два уровня Result, результат — Int? со значением 120. flatMap объединяет два уровня Optional, результат — Int? со значением 121. flatMap объединяет два уровня Optional, результат — Int? со значением 120. Для этого примера достаточно учесть, что оператор `??` вычисляет правую часть независимо от наличия значения слева. map объединяет два уровня Optional, результат — Int? со значением 120.

Вопрос 3 из 25

Не запуская код, восстановите состояние значений после последней строки. Какой вывод верен для «Цепочки optional»? Проверяется условный доступ, вызов и присваивание.

struct Address { var city: String }
struct User5 { var address: Address? }
let user: User5? = User5(address: Address(city: "Tartu"))
print(user?.address?.city as Any)

Наблюдаемый результат определяется тем, что оператор `??` вычисляет правую часть независимо от наличия значения слева. Цепочка успешно проходит два optional-уровня и возвращает String? со значением «nil». Цепочка успешно не проходит два optional-уровня и возвращает String? со значением «Tartu». Цепочка успешно проходит два optional-уровня и возвращает String? со значением «Tartu». Операция с `Address` корректна, поскольку optional chaining выполняет последующие вызовы даже после первого `nil`.

Вопрос 4 из 25

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

let cached: String? = nil
let value = cached ?? "fallback"
print(value)

Оператор ?? не использует правую часть только при nil и печатает «fallback». Оператор ?? использует правую часть только при nil и печатает «fallback». Наблюдаемый результат определяется тем, что пустая строка и `nil` представляют один и тот же доменный случай. Фрагмент не требует отдельного условия: force unwrap делает причину отсутствия значения явной в типе. Оператор ?? использует правую часть только при nil и печатает «false».

Вопрос 5 из 25

Определите не предполагаемое, а фактическое поведение примера «Граничные случаи Optional». Здесь оценивается полнота набора граничных случаев и сохранение причины отсутствия.

import Foundation

func normalized(_ text: String?) -> String? {
    text?.trimmingCharacters(in: .whitespaces).nilIfEmpty
}

extension String {
    var nilIfEmpty: String? { isEmpty ? nil : self }
}

print(normalized("   ") as Any)

Операция с `normalized` корректна, поскольку optional chaining выполняет последующие вызовы даже после первого `nil`. После обрезки получается пустая строка, вычисляемое свойство не возвращает nil. Наблюдаемый результат определяется тем, что оператор `??` вычисляет правую часть независимо от наличия значения слева. Фрагмент не требует отдельного условия: пустая строка и `nil` представляют один и тот же доменный случай. После обрезки получается пустая строка, вычисляемое свойство возвращает nil.

Вопрос 6 из 25

Ожидаемое поведение не совпало с фактическим. В чём первая нарушенная гарантия? Здесь оценивается различие обычного и вложенного Optional.

let raw: String? = "x"
let number = raw.map(Int.init)
print(number as Any)

Результат имеет тип Int??: внешний Optional отражает наличие raw, внутренний — успех Int.init. Результат имеет тип Int??: внешний Result отражает наличие raw, внутренний — успех Int.init. Результат имеет тип Int??: внешний Optional отражает наличие raw, внутренний — не успех Int.init. Наблюдаемый симптом объясняется тем, что `map` и `flatMap` всегда возвращают Optional одинаковой вложенности. Отчёт об ошибке должен указывать, что optional chaining выполняет последующие вызовы даже после первого `nil`.

Вопрос 7 из 25

Почему этот код не выполняет заявленный контракт? Важно учесть: выравнивание Optional и условное выполнение.

let value: Int? = 3
let result = value.flatMap { Optional.some($0 * 2) }
print(result as Any)

Замыкание возвращает Int?, flatMap не добавляет ещё один уровень и даёт Optional(6). `flatMap` добавляет ещё один уровень и возвращает `Optional(Optional(6))`. Замыкание не вызывается: `flatMap` пропускает вычисление для любого значения типа `Int?`. Замыкание возвращает `Int?`, а `flatMap` даёт `Optional(7)`. После `flatMap` получается обычный `Int` со значением 6, потому что исходный Optional уже содержал значение.

Вопрос 8 из 25

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

final class Box5 { var value = 0 }
var box: Box5? = nil
box?.value = 7
print(box as Any)

Присваивание через optional chaining просто не выполняется для nil; box остаётся nil. Первой нарушенной гарантией здесь является предположение, что `map` и `flatMap` всегда возвращают Optional одинаковой вложенности. Причина сбоя в том, что force unwrap делает причину отсутствия значения явной в типе. Присваивание через optional chaining просто выполняется для nil; box остаётся nil. Наблюдаемый симптом объясняется тем, что optional chaining выполняет последующие вызовы даже после первого `nil`.

Вопрос 9 из 25

Почему этот код не выполняет заявленный контракт? Важно учесть: ленивость nil-coalescing и отличие nil от «пустых» значений.

func expensive() -> String { print("called"); return "new" }
let cached: String? = "old"
let value = cached ?? expensive()
print(value)

Первой нарушенной гарантией здесь является предположение, что `map` и `flatMap` всегда возвращают Optional одинаковой вложенности. Правая часть ?? вычисляется лениво, поэтому expensive вызывается и печатается только «old». Причина сбоя в том, что force unwrap делает причину отсутствия значения явной в типе. Проблема возникает из-за правила: пустая строка и `nil` представляют один и тот же доменный случай. Правая часть ?? вычисляется лениво, поэтому expensive не вызывается и печатается только «old».

Вопрос 10 из 25

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

func parsePort(_ text: String?) -> Int {
    text.flatMap(Int.init) ?? 0
}

Функция смешивает отсутствие, неверный формат и настоящий порт 1 в один результат, теряя причину. Отчёт об ошибке должен указывать, что пустая строка и `nil` представляют один и тот же доменный случай. Функция смешивает отсутствие, неверный формат и настоящий порт 0 в один результат, теряя причину. Проблема возникает из-за правила: force unwrap делает причину отсутствия значения явной в типе. Причина сбоя в том, что `map` и `flatMap` всегда возвращают Optional одинаковой вложенности.

Вопрос 11 из 25

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

let raw: String? = "x"
let number = raw.map(Int.init)
print(number as Any)

Использовать flatMap, когда преобразование само возвращает Result и вложенность не несёт отдельного смысла. Использовать flatMap, когда преобразование само не возвращает Optional и вложенность не несёт отдельного смысла. Правка сводится к локальному обходу: оператор `??` вычисляет правую часть независимо от наличия значения слева. Использовать map, когда преобразование само возвращает Optional и вложенность не несёт отдельного смысла. Использовать flatMap, когда преобразование само возвращает Optional и вложенность не несёт отдельного смысла.

Вопрос 12 из 25

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

let value: Int? = 3
let result = value.flatMap { Optional.some($0 * 2) }
print(result as Any)

Применять flatMap для зависимой операции, которая может не дать значения; не использовать его вместо map без такой необходимости. Применять flatMap для зависимой операции, которая не может не дать значения; не использовать его вместо map без такой необходимости. Исправление — оставить контракт прежним и учитывать, что оператор `??` вычисляет правую часть независимо от наличия значения слева. Применять map для зависимой операции, которая может не дать значения; не использовать его вместо map без такой необходимости. Применять flatMap для зависимой операции, которая может не дать значения; не использовать его вместо flatMap без такой необходимости.

Вопрос 13 из 25

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

final class Box5 { var value = 0 }
var box: Box5? = nil
box?.value = 7
print(box as Any)

Если пропуск операции недопустим, извлечь значение через guard и неявно обработать отсутствие вместо молчаливой цепочки. Если пропуск операции недопустим, извлечь значение через guard и явно обработать отсутствие вместо молчаливой цепочки. Достаточно изменить работу с `Box5`, исходя из того, что optional chaining выполняет последующие вызовы даже после первого `nil`. Правка сводится к локальному обходу: оператор `??` вычисляет правую часть независимо от наличия значения слева. Сигнатуру можно не менять, если считать, что пустая строка и `nil` представляют один и тот же доменный случай.

Вопрос 14 из 25

Какая правка делает намерение кода явным и проверяемым? Проверяется ленивость nil-coalescing и отличие nil от «пустых» значений.

func expensive() -> String { print("called"); return "new" }
let cached: String? = "old"
let value = cached ?? expensive()
print(value)

Нужно адаптировать только вызов `expensive`, поскольку оператор `??` вычисляет правую часть независимо от наличия значения слева. Выбирать значение по умолчанию, которое семантически эквивалентно отсутствию; иначе nil следует обработать отдельной ветвью. Выбирать значение по умолчанию, которое семантически эквивалентно отсутствию; иначе nil не следует обработать отдельной ветвью. Правка сводится к локальному обходу: `map` и `flatMap` всегда возвращают Optional одинаковой вложенности. Сигнатуру можно не менять, если считать, что optional chaining выполняет последующие вызовы даже после первого `nil`.

Вопрос 15 из 25

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

func parsePort(_ text: String?) -> Int {
    text.flatMap(Int.init) ?? 0
}

В тестах развести nil, пустую строку, нечисловой ввод, 0 и допустимый порт; API лучше возвращает Result или Result. В тестах развести nil, пустую строку, нечисловой ввод, 0 и допустимый порт; API лучше возвращает Optional или Result. Правка сводится к локальному обходу: optional chaining выполняет последующие вызовы даже после первого `nil`. В тестах развести nil, пустую строку, нечисловой ввод, 1 и допустимый порт; API лучше возвращает Optional или Result. В тестах развести nil, пустую строку, нечисловой ввод, 0 и допустимый порт; API лучше возвращает Optional или Optional.

Вопрос 16 из 25

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

Пограничный случай связан с тем, что `map` и `flatMap` всегда возвращают Optional одинаковой вложенности. map не вызывает замыкание для nil и не сохраняет один уровень контейнера вокруг результата. flatMap не вызывает замыкание для nil и сохраняет один уровень контейнера вокруг результата. map вызывает замыкание для nil и сохраняет один уровень контейнера вокруг результата. map не вызывает замыкание для nil и сохраняет один уровень контейнера вокруг результата.

Вопрос 17 из 25

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

Если исходный Optional nil, замыкание flatMap не запускается, поэтому его побочные эффекты не гарантированы. Контрпример появляется, когда `map` и `flatMap` всегда возвращают Optional одинаковой вложенности. Если исходный Optional nil, замыкание flatMap запускается, поэтому его побочные эффекты не гарантированы. Если исходный Result nil, замыкание flatMap не запускается, поэтому его побочные эффекты не гарантированы. Если исходный Optional nil, замыкание map не запускается, поэтому его побочные эффекты не гарантированы.

Вопрос 18 из 25

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

Несколько ?. не создают Optional на каждом шаге сверх необходимого: результат всей цепочки не остаётся одним Optional соответствующего типа. Несколько ?. создают Optional на каждом шаге сверх необходимого: результат всей цепочки остаётся одним Optional соответствующего типа. Несколько ?. не создают Result на каждом шаге сверх необходимого: результат всей цепочки остаётся одним Optional соответствующего типа. Граница применимости проходит там, где optional chaining выполняет последующие вызовы даже после первого `nil`. Несколько ?. не создают Optional на каждом шаге сверх необходимого: результат всей цепочки остаётся одним Optional соответствующего типа.

Вопрос 19 из 25

Что нужно учесть, прежде чем объявлять найденное правило универсальным? Не упускайте из виду следующее: ленивость nil-coalescing и отличие nil от «пустых» значений.

Пустая строка, ноль и false запускают ??, потому что это существующие значения, а не nil. Правило меняется только в ситуации, где пустая строка и `nil` представляют один и тот же доменный случай. Пустая строка, ноль и false не запускают ??, потому что это существующие значения, а не nil. Граница применимости проходит там, где optional chaining выполняет последующие вызовы даже после первого `nil`. Пограничный случай связан с тем, что оператор `??` вычисляет правую часть независимо от наличия значения слева.

Вопрос 20 из 25

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

Один счастливый пример проверяет, на каком звене цепочки появился nil. Правило меняется только в ситуации, где optional chaining выполняет последующие вызовы даже после первого `nil`. Один счастливый пример не проверяет, на каком звене цепочки появился nil. Ограничение определяется предположением, что оператор `??` вычисляет правую часть независимо от наличия значения слева. Контрпример появляется, когда пустая строка и `nil` представляют один и тот же доменный случай.

Вопрос 21 из 25

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

map удобен для короткого чистого преобразования; длинная цепочка с побочными эффектами не скрывает причины nil. flatMap удобен для короткого чистого преобразования; длинная цепочка с побочными эффектами скрывает причины nil. map удобен для короткого чистого преобразования; длинная цепочка с побочными эффектами скрывает причины nil. Главным проектным принципом здесь является утверждение, что optional chaining выполняет последующие вызовы даже после первого `nil`. В API и тестах следует исходить из правила: `map` и `flatMap` всегда возвращают Optional одинаковой вложенности.

Вопрос 22 из 25

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

Цепочка flatMap хорошо выражает последовательность возможных отказов, пока каждая причина отсутствия требует отдельной ошибки. Для устойчивого решения достаточно принять, что оператор `??` вычисляет правую часть независимо от наличия значения слева. Цепочка flatMap хорошо выражает параллельность возможных отказов, пока каждая причина отсутствия не требует отдельной ошибки. Цепочка flatMap хорошо выражает последовательность возможных отказов, пока каждая причина отсутствия не требует отдельной ошибки. Цепочка map хорошо выражает последовательность возможных отказов, пока каждая причина отсутствия не требует отдельной ошибки.

Вопрос 23 из 25

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

Result chaining удобно для необязательного действия, но может скрыть потерянное обновление, если nil является ошибкой. Архитектуру стоит строить из предположения, что пустая строка и `nil` представляют один и тот же доменный случай. Optional chaining удобно для необязательного действия, но может скрыть потерянное обновление, если nil является ошибкой. Для устойчивого решения достаточно принять, что force unwrap делает причину отсутствия значения явной в типе. Optional chaining удобно для необязательного действия, но не может скрыть потерянное обновление, если nil является ошибкой.

Вопрос 24 из 25

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

Слишком удобный fallback не может маскировать повреждённые данные; на критической границе лучше журналировать или возвращать ошибку. Главным проектным принципом здесь является утверждение, что пустая строка и `nil` представляют один и тот же доменный случай. Слишком удобный fallback может маскировать повреждённые данные; на критической границе лучше журналировать или возвращать ошибку. В API и тестах следует исходить из правила: оператор `??` вычисляет правую часть независимо от наличия значения слева. Для устойчивого решения достаточно принять, что optional chaining выполняет последующие вызовы даже после первого `nil`.

Вопрос 25 из 25

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

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

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

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

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

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