Опционалы в языке программирования Swift OTUS
2026-03-10 03:08 Diff
https://otus.ru/journal/swift/

Константы и переменные любого типа данных в языке программирования Swift (строкового, целочисленного, числового с плавающей точкой, логического и так далее) всегда имеют некое непустое значение. Это относится также к переменным, хранящим ссылки на объекты классов: даже в этом случае переменная не может содержать никакой ссылки, она всегда указывает на какой-либо объект. (Это очень принципиальное отличие, например, от языка программирования C#, где все ссылочные переменные могут быть пустыми, то есть равными nil.)

Однако в процессе написания программы часто возникает необходимость указать для переменной именно отсутствие какого-либо значения вовсе. Для этого при программировании в Swift существуют опционалы.

Опционал (другими словами, опциональный тип данных) предоставляет собой определение переменной, реализующее следующие две возможности: переменная-опционал может содержать значение некоего определенного типа данных, называемого в дальнейшем базовым, либо не содержать ничего вообще. Для того чтобы показать отсутствие значение у переменной-опционала, нужно присвоить ей особое значение nil.

Итак, в общем виде определяется опционал следующим образом:
Optional<Type> (полный вариант записи опционала) или Type! (краткий вариант записи), где Type — базовый тип.

Например:
var x: Optional<Int>
var y: Int?

Оба варианта записи означают, что переменные x и y могут содержать целое число или не содержать ничего (быть равными nil). Также следует отметить, что оба варианта записи создадут переменные одинакового типа (то есть в дальнейшем запись x = y не вызовет ошибки несоответствия типов данных).
(Проводя дальнейшее сравнение с программированием в C#, опционал в Swift — это, по сути, обычный ссылочный тип данных в C#. Например, String? языка Swift аналогичен обычному String в C#).

Важно: при программировании на Swift при объявления переменной-опционала необходимо явно указать ее опциональный тип:

var s: String? = «строка-опционал»

(В случае записи var s = «строка» будет создана переменная обычного типа String. В случае записи var s = nil компилятором будет выдана ошибка «‘nil’ requires a contextual type» — nil требует контекстного типа).

При работе с опционалами нельзя выполнять операции непосредственно между переменными опционального и базового типа. Это приведет к ошибке во время компиляции. Пример:

var x1: Int = 111
var x2: Int? = 222

Выполнение выражения x1 + x2 вызовет ошибку «Value of optional type Int? must be unwrapped to value Int» (значение опционала должно быть распаковано). Иными словами, значение переменной-опционала должно быть неким образом преобразовано к базовому типу.

При программировании на Swift существует несколько таких механизмов преобразования опционала к базовому типу:
• force unwrapping;
• implicity unwrapping;
• optional bunding;
• nil coalescing.

Механизм force unwrapping

Механизм force unwrapping (принудительная распаковка) явно преобразует опционал в значение базового типа путем добавления восклицательного знака после имени переменной-опционала.

Например:
var x1: Int = 10
var x2: Int? = 20
var x3 = x1 + x2!

При таком способе получения значения опционала, содержащее nil, возникает ошибка во время выполнения программы.

var i: Int? = nil

Выполнение выражения i! приведет к ошибке при выполнении программы «Unexpectedly found nil while unwrapping an optional value» (Неожиданное обнаружение nil во время распаковки значения опционала).

При использовании механизма force unwrapping для получения значения переменной-опционала необходимо быть уверенным, что опционал имеет непустое значение. Для выполнения такой проверки используется условный оператор и операторы сравнения опционала с nil (равенства «==» и неравенства «!=»).

Например:
let x1: Int = 333
let x2: Int? = 444
if x2 != nil {let x3 = x1 + x2!}

Механизм implicity unwrapping

Другим вариантом извлечения значения переменной-опционала является механизм implicity unwrapping (неявного извлечения).

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

Именно в таких случаях используется механизм implicity unwrapping. Для этого при инициализации опционала знак вопроса (?) заменяется на знак восклицания (!).

let str1: String! = «implicity unwrapping»
let str2: String? = «optional string»
let str3: String! = str2! // другой вариант неявной распаковки опционала

Механизм optional binding

Механизм optinal binding (связывание опционала) используется для определения наличия в опционала непустого значения и, в случае если это так, получения значение опционала во временную переменную или константу.

В общем виде механизм optional binding выглядит следующим образом:
if let временная переменная = опционал { //действия для непустого опционала }
else { // действия для пустого опционала}

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

В противном случае, когда значение опционала не может быть извлечен (равен nil) — выполняется блок else. Блок else может отсутствовать.

var x1: Int = 100
var x2: Int? = 200
if let x_temp = x2 { let x3 = x1 + x_temp }

Механизм nil coalescing

Еще одним вариантом распаковки опционала является механизм nil coalescing (соединения с nil) с использованием оператора ??.
В общим виде такой способ выглядит следующим образом:
let переменная = опционал ?? значениепоумолчанию

В случае, когда опционал не равен nil, его значение записывается в переменную, в противном случае в переменную записывается значение по умолчанию, расположенное справа от оператора ??.

В примере приведенный механизм реализуется следующим образом:
let x1: Int = 1
let x2: Int? = 2
let temp = x2 ?? 0
let x3 = x1 + temp

Наиболее безопасными и поэтому рекомендуемыми механизмами работы с опционалами являются optional binding и nil coalescing.

Если вам интересно развитие в сфере разработки iOS-приложений, предлагаем ознакомиться с курсами iOS-разработки: базовый уровень, продвинутый уровень.