Основы Swift / 3.1. Терминология


Видео


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

Операторы бывают унарными, бинарными и тернарными:
  • Унарные операторы работают с одной целью (пример: -a). Унарные префиксные операторы пишутся непосредственно перед их целью (!b), и унарные постфиксные операторы пишутся непосредственно после их цели (c!).
  • Бинарные операторы имеют две цели (2 + 3) и являются инфиксными, так как они пишутся непосредственно между своими целями.
  • Тернарные операторы имеют три цели. В Swift есть только один тернарный оператор - это тернарный условный оператор (a ? b : c).
Операторы могут как возвращать значения, так и просто оказывать влияние на свои цели.

Те цели, на которые воздействуют операторы называются операндами. В выражении 1 + 2, символ + является бинарным оператором и его два операнда имеют значения 1 и 2.
Оператор присваивания
Оператор присваивания ( a = b ) инициализирует или обновляет значение величины a значением b:
@{3.1\1}
                    
let b = 10
var a = 5
a = b
// a теперь равно 10
                    
                
После выполнения данной операции a равно 10, то есть значению b.
Для кортежей
Если правая сторона присваивания - это кортеж с несколькими значениями, его элементы могут быть декомпозированы на несколько констант или переменных одновременно:
@{3.1\2}
                    
let (x, y) = (1, 2)
//x теперь равен 1, а y равен 2
                    
                
Арифметические операторы
Swift поддерживает четыре базовых арифметических оператора для всех числовых типов:
  • Сложение (+)
  • Вычитание (-)
  • Умножение (*)
  • Деление (/)
Все они являются операторами, возвращающими значение.

Оператор сложения также может быть использован для конкатенации (или же объединения) нескольких строк в одну.
@{3.1\3}
                    
1 + 2       // равно 3
5 - 3       // равно 2
2 * 3       // равно 6
10.0 / 2.5  // равно 4
"Здравствуй, " + "мир!" // равно "Здравствуй, мир!"
                    
                
Оператор остатка от деления
Оператор остатка (a % b) вычисляет, сколько раз b поместится в a и возвращает то значение, что осталось от a (известное как остаток) при его размещении b.

Далее Вы можете увидеть, как работает оператор остатка от деления. Чтобы вычислить 9 % 4, сперва нужно выяснить, сколько 4-ок поместится внутри 9-ки:
Рисунок 3.1.1
Оператор остатка от деления
Вы можете вложить две 4-ки внутрь одной 9-ки, так что остаток будет равен 1 (показано оранжевым).

В Swift это может быть записано как:
@{3.1\4}
                    
9 % 4 // равно 1
                    
                
Как искать остаток
Чтобы определить ответ на a % b, оператор % решает следующее уравнение и возвращает остаток в качестве вывода:

a = (b x некий множитель) + остаток

где некий множитель - это наибольшее количество b, которое можно вместить в a.

Подставив 9 и 4 в уравнение, получим:

9 = (4 x 2) + 1

Тот же метод применяется при вычислении остатка для отрицательного значения a.

Подставив -9 и 4 в уравнение, получим:

-9 = (4 x -2) + -1

что даст остаток значением -1.

Знак b игнорируется для отрицательных значений b: a % b и a % -b всегда дают одинаковый ответ.
@{3.1\5}
                    
-9 % 4 // равно -1
                    
                
Оператор унарного минуса
Знак числового значения может быть изменён на противоположный с помощью префиксного -, известного в качестве оператора унарного минуса.

Оператор унарного минуса (-) пишется без пробелов прямо перед значением, на которое оно воздействует. Он не изменяет самого своего операнда, а возвращает новое число противоположного знака.
@{3.1\6}
                    
let three = 3
let minusThree = -three // minusThree равен -3
let plusThree = -minusThree // plusThree равен 3 или "минус минус три"
                    
                
Оператор унарного плюса
Оператор унарный плюс (+) просто возвращает значение своего операнда без изменений.

Хотя оператор унарного плюса по факту ничего не делает, Вы можете использовать его для создания симметрии в Вашем коде для положительных чисел, когда Вы так же используете оператор унарного минуса для отрицательных чисел.
@{3.1\7}
                    
let minusSix = -6
let alsoMinusSix = +minusSix // alsoMinusSix равно -6
                    
                
Составные операторы присваивания
В Swift есть составные операторы присваивания, которые объединяют присваивание (=) с другой операцией. Один из примеров - оператор сложения/присваивания (+=):

Выражение a += 2 является краткой формой для a = a + 2. Фактически сложение и присваивание объединены в один оператор, который выполняет оба действия вместе.
@{3.1\8}
                    
var a = 1
a += 2
// a теперь равно 3
                    
                
Операторы сравнения
Swift поддерживает все базовые операторы сравнения:
  • Равенство (a == b)
  • Неравенство (a != b)
  • Больше чем (a > b)
  • Меньше чем (a < b)
  • Больше или равно (a >= b)
  • Меньше или равно (a <= b)
Каждый из операторов сравнения возвращает значение типа Bool для указания на то, истинно или нет выражение:
@{3.1\9}
                    
1 == 1 // истина, так как 1 равно 1
2 != 1 // истина, так как 2 не равно 1
2 > 1  // истина, так как 2 больше чем 1
1 < 2  // истина, так как 1 меньше 2
1 >= 1 // истина, так как 1 больше либо равно 1
2 <= 1 // ложь, так как 2 не меньше либо равно 1