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

Оператор является специальным символом или фразой, которую Вы используете для проверки, изменения или значений объединения. Например, оператор сложения (+) добавляют два числа вместе (как в let i = 1 + 2). Более сложные примеры включают логическую операцию И && (как в if enteredDoorCode && passedRetinaScan) и инкрементный оператор ++i, который является ярлыком для увеличивания стоимости i 1.

Swift поддерживает самых типичных операторов C и улучшает несколько возможностей устранить общие ошибки кодирования. Оператор присваивания (=) не возвращает значение, чтобы препятствовать тому, чтобы он по ошибке использовался когда равное оператору (==) предназначается. Арифметические операторы (+, -, *, /, % и т.д), обнаруживают и запрещают переполнение значения, для предотвращения неожиданных результатов при работе с числами, становящимися больше или меньшими, чем позволенный диапазон значений типа, хранящего их. Можно выбрать в оценить поведение переполнения при помощи операторов переполнения Swift, как описано в Операторах Переполнения.

В отличие от C, Swift позволяет Вам выполнить остаток (%) вычисления на числах с плавающей точкой. Swift также обеспечивает два оператора диапазона (a..<b и a...b) не найденный в C, как ярлык для выражения диапазона значений.

В этой главе описываются общих операторов в Swift. Усовершенствованные Операторы покрывают усовершенствованных операторов Swift и описывают, как определить Ваших собственных операторов и реализовать типичных операторов для Ваших собственных типов.

Терминология

Операторы являются унарными, двоичными, или троичными:

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

Значения, на которые влияют операторы, являются операндами. В выражении 1 + 2, + символ является бинарным оператором, и его два операнда являются значениями 1 и 2.

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

Оператор присваивания (a = b) инициализирует или обновляет значение a со значением b:

      let b = 10
var a = 5
a = b
// a is now equal to 10

Если правая сторона присвоения является кортежем с многократными значениями, его элементы могут анализироваться в многократные константы или переменные сразу:

      let (x, y) = (1, 2)
// x is equal to 1, and y is equal to 2

В отличие от оператора присваивания в C и Objective C, оператор присваивания в Swift самостоятельно не возвращает значение. Следующее утверждение не допустимо:

      if x = y {
    // this is not valid, because x = y does not return a value
}

Эта функция предотвращает оператор присваивания (=) от того, чтобы быть используемым случайно, когда равное оператору (==) фактически предназначается. Путем создания if x = y недопустимый, Swift помогает Вам избежать этих видов ошибок в Вашем коде.

Арифметические операторы

Swift поддерживает четыре стандартных арифметических оператора для всех типов числа:

Дополнение (+)
Вычитание (-)
Умножение (*)
Подразделение (/)

+ 2       // equals 3
- 3       // equals 2
* 3       // equals 6
0 / 2.5  // equals 4.0

В отличие от арифметических операторов в C и Objective C, арифметические операторы Swift не позволяют значениям переполняться по умолчанию. Можно выбрать в оценить поведение переполнения при помощи операторов переполнения Swift (такой как a &+ b). Посмотрите операторов переполнения.

Оператор сложения также поддерживается для String связь:

      "hello, " + "world"  // equals "hello, world"

Оператор остатка

Оператор остатка (a % b) выясняет сколько сети магазинов b будет соответствовать внутри a и возвращает значение, перенесенное (известный как остаток).

Вот то, как работает оператор остатка. Вычислять 9 % 4, Вы сначала выясняете сколько 4s будет соответствовать внутри 9:

Можно соответствовать два 4s внутри 9, и остаток 1 (показанный в оранжевом).

В Swift это было бы записано как:

      9 % 4    // equals 1

Определить ответ для a % b, % оператор вычисляет следующее уравнение и возвраты remainder как его вывод:

a = (b × some multiplier) + remainder

где some multiplier наибольшее число сети магазинов b это будет соответствовать внутри a.

Вставка 9 и 4 в это уравнение доходы:

9 = (4 × 2) + 1

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

      -9 % 4   // equals -1

Вставка -9 и 4 в доходы уравнения:

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

предоставление значения остатка -1.

Знак b проигнорирован для отрицательных величин b. Это означает это a % b и a % -b всегда давайте тот же ответ.

Вычисления остатка с плавающей точкой

В отличие от оператора остатка в C и Objective C, оператор остатка Swift может также воздействовать на числа с плавающей точкой:

      8 % 2.5   // equals 0.5

В этом примере, 8 разделенный на 2.5 равняется 3, с остатком от 0.5, таким образом, оператор остатка возвращает a Double значение 0.5.

Инкрементные и операторы понижения

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

      var i = 0
++i      // i now equals 1

Каждый раз Вы вызываете ++i, значение i увеличен 1. По существу, ++i сокращение для того, чтобы сказать i = i + 1. Аналогично, --i может использоваться в качестве сокращения для i = i - 1.

++ и -- символы могут использоваться в качестве префиксных операторов или в качестве постфиксных операторов. ++i и i++ оба допустимые способы увеличить стоимость i 1. Точно так же --i и i-- оба допустимые способы уменьшить значение i 1.

Обратите внимание на то, что эти операторы изменяют i и также возвратите значение. Если Вы только хотите постепенно увеличиться или постепенно уменьшиться, значение сохранило в i, можно проигнорировать возвращенное значение. Однако при использовании возвращенного значения это будет отличаться на основе того, использовали ли Вы префиксную или постфиксную версию оператора, согласно соблюдающим правилам:

Если оператор записан перед переменной это постепенно увеличивает переменную прежде, чем возвратить ее значение.
Если оператор записан после переменной это постепенно увеличивает переменную после возврата ее значения.

Например:

      var a = 0
let b = ++a
// a and b are now both equal to 1
let c = a++
// a is now equal to 2, but c has been set to the pre-increment value of 1

В примере выше, let b = ++a инкременты a прежде, чем возвратить его значение. Это то, почему оба a и b равны новому значению 1.

Однако let c = a++ инкременты a после возврата его значения. Это означает это c получает старое значение 1, и a тогда обновляется для равенства 2.

Если Вам не нужно определенное поведение i++, рекомендуется использовать ++i и --i во всех случаях, потому что у них есть типичное ожидаемое поведение изменения i и возврат результата.

Оператор унарный минус

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

      let three = 3
let minusThree = -three       // minusThree equals -3
let plusThree = -minusThree   // plusThree equals 3, or "minus minus three"

Оператор унарный минус (-) предварительно ожидается непосредственно перед значением это воздействует на без любого пробела.

Унарный плюс оператор

Унарное плюс оператор (+) просто возвращает значение, которым это управляет на без любого изменения:

      let minusSix = -6
let alsoMinusSix = +minusSix  // alsoMinusSix equals -6

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

Составные операторы присваивания

Как C, Swift обеспечивает составные операторы присваивания то присвоение объединения (=) с другой работой. Одним примером является дополнительный оператор присваивания (+=):

      var a = 1
a += 2
// a is now equal to 3

Выражение a += 2 сокращение для a = a + 2. Эффективно, дополнение и присвоение объединены в одного оператора, выполняющего обе задачи одновременно.

Полный список составных операторов присваивания может быть найден в Выражениях.

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

Swift поддерживает весь стандарт C операторы сравнения:

Равный (a == b)
Не равняются (a != b)
Больше, чем (a > b)
Меньше, чем (a < b)
Больше, чем или равный (a >= b)
Меньше чем или равный (a <= b)

Каждый из операторов сравнения возвращает a Bool значение, чтобы указать, является ли оператор истиной:

== 1   // true, because 1 is equal to 1
!= 1   // true, because 2 is not equal to 1
> 1    // true, because 2 is greater than 1
< 2    // true, because 1 is less than 2
>= 1   // true, because 1 is greater than or equal to 1
<= 1   // false, because 2 is not less than or equal to 1

Операторы сравнения часто используются в условных операторах, такой как if оператор:

      let name = "world"
if name == "world" {
    println("hello, world")
} else {
    println("I'm sorry \(name), but I don't recognize you")
}
// prints "hello, world", because name is indeed equal to "world"

Для больше на if оператор, посмотрите Поток управления.

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

Троичный условный оператор является специальным оператором с тремя частями, принимающим форму question ? answer1 : answer2. Это - ярлык для оценки одного из двух выражений на основе ли question истина или ложь. Если question истина, она оценивает answer1 и возвращает его значение; иначе, это оценивает answer2 и возвращает его значение.

Троичный условный оператор является сокращением для кода ниже:

      if question {
    answer1
} else {
    answer2
}

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

      let contentHeight = 40
let hasHeader = true
let rowHeight = contentHeight + (hasHeader ? 50 : 20)
// rowHeight is equal to 90

Предыдущим примером является сокращение для кода ниже:

      let contentHeight = 40
let hasHeader = true
var rowHeight = contentHeight
if hasHeader {
    rowHeight = rowHeight + 50
} else {
    rowHeight = rowHeight + 20
}
// rowHeight is equal to 90




  

Использование первого примера троичного условного оператора означает это rowHeight может быть установлен в правильное значение на одной строке кода. Это более кратко, чем второй пример и устраняет необходимость rowHeight быть переменной, потому что ее значение не должно быть изменено в if оператор.

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

Нулевой оператор объединения

Нулевой оператор объединения (a ?? b) разворачивает дополнительное a если это содержит значение или возвращает значение по умолчанию b если a nil. Выражение a всегда имеет дополнительный тип. Выражение b должен соответствовать тип, который сохранен внутри a.

Нулевой оператор объединения является сокращением для кода ниже:

      a != nil ? a! : b

Код выше использует троичный условный оператор и вызванное разворачивание (a!) получить доступ к значению перенеслось внутри a когда a не nil, и возвратиться b иначе. Нулевой оператор объединения обеспечивает более изящный способ инкапсулировать эту условную проверку и разворачивание в краткой и удобочитаемой форме.

Пример ниже использует нулевого оператора объединения для выбора между именем цвета по умолчанию и дополнительным именем определяемого пользователем цвета:

      let defaultColorName = "red"
var userDefinedColorName: String?   // defaults to nil
 
var colorNameToUse = userDefinedColorName ?? defaultColorName
// userDefinedColorName is nil, so colorNameToUse is set to the default of "red"

userDefinedColorName переменная определяется как дополнительное String, со значением по умолчанию nil. Поскольку userDefinedColorName имеет дополнительный тип, можно использовать нулевого оператора объединения для рассмотрения его значения. В примере выше, оператор используется для определения начального значения для a String переменную вызывают colorNameToUse. Поскольку userDefinedColorName nil, выражение userDefinedColorName ?? defaultColorName возвращает значение defaultColorName, или "red".

Если Вы присваиваетесь не -nil значение к userDefinedColorName и выполните ноль, объединяющий проверку оператора снова, значение, обернутое внутри userDefinedColorName используется вместо значения по умолчанию:

      userDefinedColorName = "green"
colorNameToUse = userDefinedColorName ?? defaultColorName
// userDefinedColorName is not nil, so colorNameToUse is set to "green"

Операторы диапазона

Swift включает два оператора диапазона, которые являются ярлыками для выражения диапазона значений.

Закрытый оператор диапазона

Закрытый оператор диапазона (a...b) определяет диапазон, работающий от a к b, и включает значения a и b. Значение a не должно быть больше, чем b.

Закрытый оператор диапазона полезен при итерации по диапазону, в котором Вы хотите, чтобы все значения использовались, такой как с a for-in цикл:

      for index in 1...5 {
    println("\(index) times 5 is \(index * 5)")
}
// 1 times 5 is 5
// 2 times 5 is 10
// 3 times 5 is 15
// 4 times 5 is 20
// 5 times 5 is 25




  

Для больше на for-in циклы, посмотрите Поток управления.

Полуоткрытый оператор диапазона

Полуоткрытый оператор диапазона (a..<b) определяет диапазон, работающий от a к b, но не включает b. Это, как говорят, является полуоткрытым, потому что это содержит свое первое значение, но не свое окончательное значение. Как с закрытым оператором диапазона, значением a не должно быть больше, чем b. Если значение a равно b, тогда получающийся диапазон будет пуст.

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

      let names = ["Anna", "Alex", "Brian", "Jack"]
let count = names.count
for i in 0..<count {
    println("Person \(i + 1) is called \(names[i])")
}
// Person 1 is called Anna
// Person 2 is called Alex
// Person 3 is called Brian
// Person 4 is called Jack




  

Обратите внимание на то, что массив содержит четыре элемента, но 0..<count только количества до 3 (индекс последнего элемента в массиве), потому что это - полуоткрытый диапазон. Для больше на массивах, посмотрите Массивы.

Логические операторы

Логические операторы изменяют или комбинируют значения Булевой логики true и false. Swift поддерживает три стандартных логических оператора, найденные на языках на базе С:

Логичный НЕ (!a)
Логический AND (a && b)
Логический OR (a || b)

Логичный НЕ оператор

Логическое НЕ оператор (!a) инвертирует булево значение так, чтобы true становится false, и false становится true.

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

      let allowedEntry = false
if !allowedEntry {
    println("ACCESS DENIED")
}
// prints "ACCESS DENIED"

Фраза if !allowedEntry может быть считан как “если не позволенный запись”. Если “не позволенный запись” истина, последующая строка только выполняется; т.е. если allowedEntry false.

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

Логическая операция И

Логическая операция И (a && b) создает логические выражения, где оба значения должны быть true для полного выражения, чтобы также быть true.

Если любое значение false, полное выражение также будет false. Фактически, если первое значение false, второе значение не будет даже оценено, потому что оно не может возможно заставить полное выражение приравняться к true. Это известно как оценка короткого замыкания.

Этот пример рассматривает два Bool если оба значения, значения и только предоставляют доступ true:

      let enteredDoorCode = true
let passedRetinaScan = false
if enteredDoorCode && passedRetinaScan {
    println("Welcome!")
} else {
    println("ACCESS DENIED")
}
// prints "ACCESS DENIED"




  

Логическая операция ИЛИ

Логическая операция ИЛИ (a || b) инфиксный оператор, сделанный из двух смежных символов вертикальной черты. Вы используете его для создания логических выражений, в которых только одно из двух значений должно быть true для полного выражения, чтобы быть true.

Как Логическая операция И выше, Логическая операция ИЛИ использует оценку короткого замыкания для рассмотрения ее выражений. Если левая сторона Логического выражения OR true, правая сторона не оценена, потому что она не может изменить результат полного выражения.

В примере ниже, первое Bool значение (hasDoorKey) false, но второе значение (knowsOverridePassword) true. Поскольку одно значение true, полное выражение также оценивает к true, и доступ предоставляется:

      let hasDoorKey = false
let knowsOverridePassword = true
if hasDoorKey || knowsOverridePassword {
    println("Welcome!")
} else {
    println("ACCESS DENIED")
}
// prints "Welcome!"




  

Объединение логических операторов

Можно объединить многократные логические операторы для создания более длинных составных выражений:

      if enteredDoorCode && passedRetinaScan || hasDoorKey || knowsOverridePassword {
    println("Welcome!")
} else {
    println("ACCESS DENIED")
}
// prints "Welcome!"

Этот пример многократное использование && и || операторы для создания более длинного составного выражения. Однако && и || операторы все еще воздействуют только на два значения, таким образом, это - фактически три меньших выражения, объединенные в цепочку вместе. Пример может быть считан как:

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

На основе значений enteredDoorCode, passedRetinaScan, и hasDoorKey, первые два подвыражения false. Однако чрезвычайный пароль переопределения известен, таким образом, полное составное выражение все еще оценивает к true.

Явные круглые скобки

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

      if (enteredDoorCode && passedRetinaScan) || hasDoorKey || knowsOverridePassword {
    println("Welcome!")
} else {
    println("ACCESS DENIED")
}
// prints "Welcome!"

Круглые скобки проясняют, что первые два значения рассматривают как часть отдельного возможного состояния в полной логике. Вывод составного выражения не изменяется, но полное намерение более ясно читателю. Удобочитаемость всегда предпочитается по краткости; используйте круглые скобки, где они помогают ясно дать понять Ваши намерения.