Swift язык программирования: выражения

Выражения

В Swift существует четыре вида выражений: префиксные выражения, двоичные выражения, первичные выражения и постфиксные выражения. Оценка выражения возвращает значение, вызывает побочный эффект или обоих.

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

Грамматика выражения

выражение → «префиксные двоичные выражения выражения _{выбирает»}

список выражений → выражение - выражение -,список выражения -

Префиксные выражения

Префиксные выражения комбинируют дополнительный префиксный оператор с выражением. Префиксные операторы берут один параметр, выражение, следующее за ними.

Библиотека стандарта Swift обеспечивает следующие префиксные операторы:

++ Инкремент
-- Декремент
! Логичный НЕТ
~ Битовое «НЕ»
+ Унарный плюс
- Унарный минус

Для получения информации о поведении этих операторов посмотрите Основных Операторов и Усовершенствованных Операторов.

В дополнение к типичным упомянутым выше операторам библиотеки Вы используете & сразу перед именем переменной это передается как в - параметр выражению вызова функции. Для получения дополнительной информации и видеть пример, посмотрите Изменяемые параметры.

Грамматика префиксного выражения

префиксное выражение → «префиксный оператор _{выбирает} постфиксное выражение»

префиксное выражение → «в выражении»

«в выражении » → &идентификатор -

Двоичные выражения

Двоичные выражения комбинируют инфиксного бинарного оператора с выражением, которое он берет в качестве его левых и правых параметров. Это имеет следующую форму:

left-hand argument operator right-hand argument

Библиотека стандарта Swift обеспечивает следующих бинарных операторов:

Exponentiative (Никакая ассоциативность, уровень 160 приоритета)
- << Поразрядный сдвиг влево
- >> Поразрядный сдвиг вправо
Мультипликативный (Левоассоциативный, уровень 150 приоритета)
- * Умножиться
- / Разделиться
- % Остаток
- &* Умножьтесь, игнорируя переполнение
- & Поразрядный AND
Дополнение (Левоассоциативный, уровень 140 приоритета)
- + Добавить
- - Вычесть
- &+ Добавьте с переполнением
- &- Вычтите с переполнением
- | Битовое «ИЛИ»
- ^ Поразрядный XOR
Диапазон (Никакая ассоциативность, уровень 135 приоритета)
- ..< Полуоткрытый диапазон
- ... Закрытый диапазон
Бросок (Никакая ассоциативность, уровень 132 приоритета)
- is Введите проверку
- as, as?, и as! Введите бросок
Нулевое Объединение (Правоассоциативный, уровень 131 приоритета)
- ?? Нулевое объединение
Сравнительный (Никакая ассоциативность, уровень 130 приоритета)
- < Меньше, чем
- <= Меньше чем или равный
- > Больше, чем
- >= Больше, чем или равный
- == Равный
- != Не равный
- === Идентичный
- !== Не идентичный
- ~= Соответствие образца
Соединительный (Левоассоциативный, уровень 120 приоритета)
- && Логический AND
Альтернативный (Левоассоциативный, уровень 110 приоритета)
- || Логический OR
Троичное Условное выражение (Правоассоциативный, уровень 100 приоритета)
- ?: Троичное условное выражение
Присвоение (Правоассоциативный, уровень 90 приоритета)
- = Присвоиться
- *= Умножьтесь и присвойтесь
- /= Разделитесь и присвойтесь
- %= Остаток и присваивается
- += Добавьте и присвойтесь
- -= Вычтите и присвойтесь
- <<= Оставленный сдвиг разряда и присваивается
- >>= Правильный сдвиг разряда и присваивается
- &= Поразрядный AND и присваивается
- ^= Поразрядные XOR и присваиваются
- |= Битовое «ИЛИ» и присваивается
- &&= Логический AND и присваивается
- ||= Логический OR и присваивается

Грамматика двоичного выражения

двоичное выражение → «бинарный оператор снабжает префиксом выражение»

двоичное выражение → «оператор присваивания снабжает префиксом выражение»

двоичное выражение → «условный оператор снабжает префиксом выражение»

двоичное выражение → оператор преобразования типа -

двоичные выражения → «двоичные выражения двоичного выражения _{выбирают»}

Оператор присваивания

Оператор присваивания устанавливает новое значение для данного выражения. Это имеет следующую форму:

```
expression = value
```

Значение выражения установлено в значение, полученное путем оценки значения. Если выражение является кортежем, значение должно быть кортежем с тем же числом элементов. (Вложенные кортежи позволяются.) Присвоение выполняется от каждой части значения к соответствующей части выражения. Например:

      (a, _, (b, c)) = ("test", 9.45, (12, 3))
// a is "test", b is 12, c is 3, and 9.45 is ignored

Оператор присваивания не возвращает значения.

Грамматика оператора присваивания

оператор присваивания → =

Троичный условный оператор

Троичный условный оператор оценивает к одному из двух данных значений на основе значения условия. Это имеет следующую форму:

condition ? expression used if true : expression used if false

Если условие оценивает к true, условный оператор оценивает первое выражение и возвращает его значение. Иначе, это оценивает второе выражение и возвращает его значение. Неиспользованное выражение не оценено.

Для примера, использующего троичный условный оператор, посмотрите Троичный Условный оператор.

Грамматика условного оператора

условный оператор → ?выражение -:

Преобразование типа операторов

Существует четыре оператора преобразования типа: is оператор, as оператор, as? оператор, и as! оператор.

У них есть следующая форма:

```
expression is type
```
```
expression as type
```
```
expression as? type
```
```
expression as! type
```

is во время выполнения оператор проверяет, может ли выражение быть нисходящим к указанному типу. Это возвращается true если выражение может быть нисходящим к указанному типу; иначе, это возвращается false.

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

      func f(any: Any) { println("Function for Any") }
func f(int: Int) { println("Function for Int") }
let x = 10
f(x)
// prints "Function for Int"
 
let y: Any = x
f(y)
// prints "Function for Any"
 
f(x as Any)
// prints "Function for Any"

Образование моста позволяет Вам использовать выражение типа библиотеки стандарта Swift такой как String как его соответствующий тип Основы такой как NSStringне будучи должен создать новый экземпляр. Для получения дополнительной информации об образовании моста посмотрите Работу с Типами данных Какао в Использовании Swift с Какао и Objective C.

as? оператор выполняет условный бросок выражения к указанному типу. as? оператор возвращает дополнительный из указанного типа. Во время выполнения, если бросок успешно выполняется, значение выражения обертывается в дополнительное и возвращенный; иначе, значение возвратилось, nil. Если кастинг к указанному типу, как гарантируют, перестанет работать или, как гарантируют, успешно выполнится, ошибка времени компиляции повышена.

as! оператор выполняет принудительный бросок выражения к указанному типу. as! оператор возвращает значение указанного типа, не дополнительного типа. Если бросок перестал работать, ошибка периода выполнения повышена. Поведение x as! T совпадает с поведением (x as? T)!.

Для получения дополнительной информации о преобразовании типа и видеть примеры, использующие операторов преобразования типа, посмотрите Преобразование типа.

Грамматика оператора преобразования типа

оператор преобразования типа → isвведите -

оператор преобразования типа → asвведите -

оператор преобразования типа → as?введите -

оператор преобразования типа → as!введите -

Первичные выражения

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

Грамматика первичного выражения

первичное выражение → «идентификатор универсальный пункт параметра _{выбирает»}

первичное выражение → литеральное выражение -

первичное выражение → самовыражение -

первичное выражение → выражение суперкласса -

первичное выражение → выражение закрытия -

первичное выражение → заключенное в скобки выражение -

первичное выражение → неявное задействованное выражение -

первичное выражение → подстановочное выражение -

Литерал

Литерал состоит или из обычного литерала (такого как строка или из числа), массив или литерал словаря или один из следующих специальных литералов:


Литерал	Ввести	Значение
`__FILE__`	`String`	Имя файла, в котором это появляется.
`__LINE__`	`Int`	Номер строки, на котором это появляется.
`__COLUMN__`	`Int`	Номер столбца, в котором это начинается.
`__FUNCTION__`	`String`	Имя объявления, в котором это появляется.

В функции, значении __FUNCTION__ имя той функции, в методе, это - имя того метода в методе get свойства или методе set, как который это является имя того свойства в специальных элементах init или subscript это - имя того ключевого слова, и на верхнем уровне файла это - имя текущего модуля.

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

      func logFunctionName(string: String = __FUNCTION__) {
    println(string)
}
func myFunction() {
    logFunctionName() // Prints "myFunction()".
}
 
myFunction()
namedArgs(1, withJay: 2)

Литерал массивов является упорядоченным набором значений. Это имеет следующую форму:

```
[value 1, value 2, ...]
```

Последнее выражение в массиве может сопровождаться дополнительной запятой. Значение литерала массивов имеет тип [T], где T тип выражений в нем. Если существуют выражения многократных типов, T их самый близкий общий супертип. Литералы пустого массива записаны с помощью пустой пары квадратных скобок и могут использоваться для создания пустого массива указанного типа.

      var emptyArray: [Double] = []

Литерал словаря является неупорядоченным набором пар ключ/значение. Это имеет следующую форму:

```
[key 1: value 1, key 2: value 2, ...]
```

Последнее выражение в словаре может сопровождаться дополнительной запятой. Значение литерала словаря имеет тип [Key: Value], где Key тип его ключевых выражений и Value тип его выражений. Если существуют выражения многократных типов, Key и Value самый близкий общий супертип для их соответствующих значений. Пустой литерал словаря записан как двоеточие в паре скобок ([:]) отличать его от литерала пустого массива. Можно использовать пустой литерал словаря для создания пустого литерала словаря указанного ключа и типов значения.

      var emptyDictionary: [String: Double] = [:]

Грамматика литерала

литерал → литерал -

литерал → литерал массива - литерал словаря -

литерал → __FILE__ __LINE__ __COLUMN__ __FUNCTION__

литерал массивов → [«элементы литерала массивов _{выбирают»}]

элементы литерала массивов → элемент литерала массивов -,_{выберите} - элемент литерала массивов -,элементы литерала массивов -

элемент литерала массивов → выражение -

литерал словаря → [литеральные элементы словаря -] [:]

литеральные элементы словаря → литеральный элемент словаря -,_{выберите} - литеральный элемент словаря -,литеральные элементы словаря -

литеральный элемент словаря → выражение -:выражение -

Сам выражение

self выражение является прямой ссылкой на текущий тип или экземпляр типа, в котором это происходит. Это имеет следующие формы:

```
self
```
```
self.member name
```
```
self[subscript index]
```
```
self(initializer arguments)
```
```
self.init(initializer arguments)
```

В инициализаторе, нижнем индексе или методе экземпляра, self относится к текущему экземпляру типа, в котором он происходит. В методе типа, self относится к текущему типу, в котором это происходит.

self когда существует другая переменная того же имени в объеме, таком как параметр функции, выражение используется для указания объема при доступе к элементам, обеспечении разрешения неоднозначности. Например:

      class SomeClass {
    var greeting: String
    init(greeting: String) {
        self.greeting = greeting
    }
}

В методе видоизменения типа значения можно присвоить новый экземпляр того типа значения к self. Например:

      struct Point {
    var x = 0.0, y = 0.0
    mutating func moveByX(deltaX: Double, y deltaY: Double) {
        self = Point(x: x + deltaX, y: y + deltaY)
    }
}

Грамматика сам выражение

самовыражение → self

самовыражение → self.идентификатор -

самовыражение → self[выражение -]

самовыражение → self.init

Выражение суперкласса

Выражение суперкласса позволяет классу взаимодействовать с его суперклассом. Это имеет одну из следующих форм:

```
super.member name
```
```
super[subscript index]
```
```
super.init(initializer arguments)
```

Первая форма используется для доступа к элементу суперкласса. Вторая форма используется для доступа к нижней реализации суперкласса. Третья форма используется для доступа к инициализатору суперкласса.

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

Грамматика выражения суперкласса

выражение суперкласса → выражение метода суперкласса - нижнее выражение суперкласса - выражение инициализатора суперкласса -

выражение метода суперкласса → super.идентификатор -

нижнее выражение суперкласса → super[выражение -]

выражение инициализатора суперкласса → super.init

Выражение закрытия

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

```
{ (parameters) -> return type in
```
```
    statements
```
```
}
```

Параметры имеют ту же форму как параметры в объявлении функции, как описано в Объявлении функции.

Существует несколько специальных форм, позволяющих закрытиям быть записанными более кратко:

Закрытие может опустить типы своих параметров, его тип возврата или обоих. Если Вы опускаете названия параметра и оба типа, опускаете in ключевое слово перед операторами. Если опущенные типы не могут быть выведены, ошибка времени компиляции повышена.
Закрытие может опустить имена для своих параметров. Его параметры тогда неявно называют $ сопровождаемый их позицией: $0, $1, $2, и т.д.
Закрытие, состоящее из только отдельного выражения, как понимают, возвращает значение того выражения. Содержание этого выражения также рассматривают при выполнении вывода типа по окружающему выражению.

Следующие выражения закрытия эквивалентны:

      myFunction {
    (x: Int, y: Int) -> Int in
    return x + y
}
 
myFunction {
    (x, y) in
    return x + y
}
 
myFunction { return $0 + $1 }
 
myFunction { $0 + $1 }

Для получения информации о передаче закрытия как параметр функции посмотрите Выражение Вызова функции.

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

Каждая запись в списке получения может быть отмечена как weak или unowned получать слабую или ненаходящуюся в собственности ссылку на значение.

      myFunction { print(self.title) }                    // strong capture
myFunction { [weak self] in print(self!.title) }    // weak capture
myFunction { [unowned self] in print(self.title) }  // unowned capture

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

      // Weak capture of "self.parent" as "parent"
myFunction { [weak parent = self.parent] in print(parent!.title) }

Для получения дополнительной информации и примеры выражений закрытия, посмотрите Выражения Закрытия.

Грамматика выражения закрытия

выражение закрытия → {«подпись закрытия _{выбирает} операторы»}

подпись закрытия → «результат функции пункта параметра _{выбирает»}in

подпись закрытия → «результат функции списка идентификаторов _{выбирает»}in

подпись закрытия → «результат функции пункта параметра списка получения _{выбирает»}in

подпись закрытия → «результат функции списка идентификаторов списка получения _{выбирает»}in

подпись закрытия → список получения -in

список получения → [выражение спецификатора получения -]

спецификатор получения → weak unowned unowned(safe) unowned(unsafe)

Неявное задействованное выражение

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

```
.member name
```

Например:

      var x = MyEnumeration.SomeValue
x = .AnotherValue

Грамматика неявного задействованного выражения

неявное задействованное выражение → .идентификатор -

Заключенное в скобки выражение

Заключенное в скобки выражение состоит из списка разделенных запятой значений выражений, окруженных круглыми скобками. Каждое выражение может иметь дополнительный идентификатор перед ним, разделенный двоеточием (:). Это имеет следующую форму:

(identifier 1: expression 1, identifier 2: expression 2, ...)

Используйте заключенные в скобки выражения, чтобы создать кортежи и передать параметры вызову функции. Если существует только одно значение в заключенном в скобки выражении, тип заключенного в скобки выражения является типом того значения. Например, тип заключенного в скобки выражения (1) Int, нет (Int).

Грамматика заключенного в скобки выражения

заключенное в скобки выражение → («список элемента выражения _{выбирает»})

список элемента выражения → элемент выражения - элемент выражения -,список элемента выражения -

элемент выражения → выражение - идентификатор -:выражение -

Выражение с подстановочными знаками

Выражение с подстановочными знаками используется для явного игнорирования значения во время присвоения. Например, в следующем присвоении 10 присваивается x и 20 проигнорирован:

      (x, _) = (10, 20)
// x is 10, and 20 is ignored

Грамматика выражения с подстановочными знаками

выражение с подстановочными знаками → _

Постфиксные выражения

Постфиксные выражения формируются путем применения постфиксного оператора или другого постфиксного синтаксиса к выражению. Синтаксически, каждое первичное выражение является также постфиксным выражением.

Библиотека стандарта Swift обеспечивает следующие постфиксные операторы:

++ Инкремент
-- Декремент

Грамматика постфиксного выражения

постфиксное выражение → основное выражение -

постфиксное выражение → постфиксный оператор постфиксного выражения -

постфиксное выражение → функциональное вызывающее выражение -

постфиксное выражение → выражение инициализатора -

постфиксное выражение → явное задействованное выражение -

постфиксное выражение → «снабжает постфиксом сам выражение»

постфиксное выражение → динамическое выражение типа -

постфиксное выражение → нижнее выражение -

постфиксное выражение → принудительное выражение -

постфиксное выражение → дополнительное выражение объединения в цепочку -

Выражение вызова функции

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

function name(argument value 1, argument value 2)

Имя функции может быть любым выражением, значение которого имеет функциональный тип.

Если функциональное определение включает имена для своих параметров, вызов функции должен включать имена перед своими значениями аргументов, разделенными двоеточием (:). Этот вид выражения вызова функции имеет следующую форму:

function name(argument name 1: argument value 1, argument name 2: argument value 2)

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

      // someFunction takes an integer and a closure as its arguments
someFunction(x, {$0 == 13})
someFunction(x) {$0 == 13}

Если запаздывающее закрытие является единственным параметром функции, круглые скобки могут быть опущены.

      // someFunction takes a closure as its only argument
myData.someMethod() {$0 == 13}
myData.someMethod {$0 == 13}

Грамматика выражения вызова функции

функциональное вызывающее выражение → «постфиксное выражение заключило выражение в скобки»

функциональное вызывающее выражение → «заключенное в скобки выражение постфиксного выражения _{выбирает}, запаздывая закрытие»

закрытие запаздывания → выражение закрытия -

Выражение инициализатора

Выражение инициализатора обеспечивает доступ к инициализатору типа. Это имеет следующую форму:

```
expression.init(initializer arguments)
```

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

      var x = SomeClass.someClassFunction // ok
var y = SomeClass.init              // error

Вы также используете выражение инициализатора для делегирования к инициализатору суперкласса.

      class SomeSubClass: SomeSuperClass {
    override init() {
        // subclass initialization goes here
        super.init()
    }
}

Грамматика выражения инициализатора

выражение инициализатора → постфиксное выражение -.init

Явное задействованное выражение

Явное задействованное выражение предоставляет доступ элементам именованного типа, кортежа или модуля. Это состоит из периода (.) между элементом и идентификатором его элемента.

```
expression.member name
```

Элементы именованного типа называют как часть объявления или расширения типа. Например:

      class SomeClass {
    var someProperty = 42
}
let c = SomeClass()
let y = c.someProperty  // Member access

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

      var t = (10, 20, 30)
t.0 = t.1
// Now t is (20, 20, 30)

Элементы модуля получают доступ к объявлениям верхнего уровня того модуля.

Грамматика явного задействованного выражения

явное задействованное выражение → постфиксное выражение -.десятичные цифры -

явное задействованное выражение → постфиксное выражение -.«идентификатор универсальный пункт параметра _{выбирает»}

Постфикс сам выражение

Постфикс self выражение состоит из выражения или имени типа, сразу сопровождаемого .self. Это имеет следующие формы:

```
expression.self
```
```
type.self
```

Первая форма оценивает к значению выражения. Например, x.self оценивает к x.

Вторая форма оценивает к значению типа. Используйте эту форму для доступа к типу как к значению. Например, потому что SomeClass.self оценивает к SomeClass введите себя, можно передать его функции или методу, принимающему аргумент level типа.

Грамматика сам выражение

«снабдите постфиксом сам выражение » → постфиксное выражение -.self

Динамическое выражение типа

A dynamicType выражение состоит из выражения, сразу сопровождаемого .dynamicType. Это имеет следующую форму:

```
expression.dynamicType
```

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

      class SomeBaseClass {
    class func printClassName() {
        println("SomeBaseClass")
    }
}
class SomeSubClass: SomeBaseClass {
    override class func printClassName() {
        println("SomeSubClass")
    }
}
let someInstance: SomeBaseClass = SomeSubClass()
// someInstance has a static type of SomeBaseClass at compile time, and
// it has a dynamc type of SomeSubClass at runtime
someInstance.dynamicType.printClassName()
// prints "SomeSubClass"




  

Грамматика динамического выражения типа

динамическое выражение типа → постфиксное выражение -.dynamicType

Нижнее выражение

Нижнее выражение обеспечивает нижний доступ с помощью метода get и метода set соответствующего нижнего объявления. Это имеет следующую форму:

```
expression[index expressions]
```

Для оценки значения нижнего выражения нижнего метода get для типа выражения вызывают с индексными выражениями, переданными как нижние параметры. Для установки его значения нижний метод set вызывают таким же образом.

Для получения информации о нижних объявлениях посмотрите Объявление Нижнего индекса Протокола.

Грамматика нижнего выражения

нижнее выражение → постфиксное выражение -[список выражения -]

Принудительное выражение

Принудительное выражение разворачивает дополнительное значение, что Вы уверены, не nil. Это имеет следующую форму:

```
expression!
```

Если значение выражения не nil, дополнительное значение развернуто и возвращено с соответствующим обязательным типом. Иначе, ошибка периода выполнения повышена.

Развернутое значение принудительного выражения может быть изменено, или путем видоизменения самого значения, или путем присвоения одному из элементов значения. Например:

      var x: Int? = 0
x!++
// x is now 1
 
var someDictionary = ["a": [1, 2, 3], "b": [10, 20]]
someDictionary["a"]![0] = 100
// someDictionary is now [b: [10, 20], a: [100, 2, 3]]

Грамматика принудительного выражения

принудительное выражение → постфиксное выражение -!

Дополнительно объединяющее в цепочку выражение

Дополнительно объединяющее в цепочку выражение обеспечивает упрощенный синтаксис для использования дополнительных значений в постфиксных выражениях. Это имеет следующую форму:

```
expression?
```

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

Если постфиксное выражение, содержащее дополнительно объединяющее в цепочку выражение, вкладывается в других постфиксных выражениях, только наиболее удаленное выражение возвращает дополнительный тип. В примере ниже, когда c не nil, его значение разворачивается и используется для оценки .property, значение которого используется для оценки .performAction(). Все выражение c?.property.performAction() имеет значение дополнительного типа.

      var c: SomeClass?
var result: Bool? = c?.property.performAction()

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

      var result: Bool? = nil
if let unwrappedC = c {
    result = unwrappedC.property.performAction()
}

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

      func someFunctionWithSideEffects() -> Int {
    return 42  // No actual side effects.
}
var someDictionary = ["a": [1, 2, 3], "b": [10, 20]]
 
someDictionary["not here"]?[0] = someFunctionWithSideEffects()
// someFunctionWithSideEffects is not evaluated
// someDictionary is still [b: [10, 20], a: [1, 2, 3]]
 
someDictionary["a"]?[0] = someFunctionWithSideEffects()
// someFunctionWithSideEffects is evaluated and returns 42
// someDictionary is now [b: [10, 20], a: [42, 2, 3]]

Грамматика дополнительно объединяющего в цепочку выражения

дополнительное выражение объединения в цепочку → постфиксное выражение -?

Типы

Операторы