Swift поддерживает большинство стандартных операторов, используемых в других языках программирования. Кроме того, Swift повышает безопасность при использовании этих операторов.
Все стандартные операторы подразделяются на 3 типа операторов. Они есть:
- Унарный оператор: Унарный оператор работает с одним операндом. Его можно поставить перед операндом (префикс) или за операндом (постфикс). Примерами префиксного унарного оператора являются -variable1, -10 и !variable2. Пример постфиксного унарного оператора: variable3!
- Бинарный оператор: Бинарный оператор работает между двумя операндами. Примеры бинарных операторов: a + b, c/d и e * f.
- Тернарный оператор: Тернарный оператор работает с 3 операндами. В Swift есть только один тернарный оператор; это тернарный условный оператор (a ? b : c)
В выражении 1 + 2 знак "плюс" — это оператор, а числа — операнды.
Оператор присваивания
Наиболее распространенным и основным оператором является оператор присваивания. Основной синтаксис следующий:
‹имя_переменной› = ‹значение/выражение_которое_соответствует_типу_данных›
Пример:
var sampleNumber1 = 0 sampleNumber1 = 256 let sampleNumber2 = 242 sampleNumber1 = sampleNumber2 print(sampleNumber2)
Для кортежей мы можем присвоить сразу несколько значений нескольким переменным/константам.
Пример:
let (a, b, c) = (12, 2.78, “Test”) a b c
Оператор присваивания не возвращает значение
В отличие от других языков программирования, оператор присваивания Swift не возвращает числовое или логическое значение.
В программировании на C мы можем комбинировать оператор присваивания с оператором if, например, если a = b {…}. В программировании на C a = b вернет true, если присваивание выполнено успешно.
Мы не можем комбинировать присваивание и оператор if в Swift, потому что оператор присваивания в Swift ничего не возвращает. Чтобы сравнить присвоенное значение, мы должны использовать оператор сравнения.
Арифметический оператор
Как и в других языках программирования, у нас есть стандартный арифметический оператор, как показано ниже:
- Дополнение (+)
- Вычитание (-)
- Умножение (*)
- Разделение (/)
Вышеупомянутый арифметический оператор является бинарным оператором и работает между двумя операндами, как показано в примере ниже:
12+54 132–65 23*65 9823 / 3 // For division, please be aware of floating point data type 9823 / 3.0
Дополнительное примечание:
- Чтобы получить точный результат, используйте для деления числа с плавающей запятой.
- Обратите внимание, что при делении любого числа на ноль будет возвращена ошибка
Как упоминалось ранее в разделе о типах данных, в Swift нет целочисленного переполнения. Swift вернет ошибку при любой попытке целочисленного переполнения.
Пример:
let intMax = Int.max // intMax is 9223372036854775807 //let test1 = intMax + 1 //Above statement will generate error remove the comment for testing
Остаточный оператор
Остаточный оператор обозначается как %. Этот оператор вернет остаток после выполнения деления. Например, 11 % 3 вернет остаток 2, а 11 % 2 даст остаток 1. См. пример ниже.
Пример:
11%3 10%3 11%2
Правила оператора остатка
Swift использует следующую формулу: a = (b * некоторый множитель) + остаток для получения остатка. Знак b всегда игнорируется. Следовательно, %b и %-b всегда дают один и тот же ответ. -a % b даст вам отрицательное число. Также обратите внимание, что оператор остатка Swift работает только с целыми числами и не работает с числами с плавающей запятой.
Оператор остатка с отрицательным числом
Оператор остатка также работает с отрицательным числом. Однако остаток будет отрицательным, только если первый операнд (делимое) отрицателен. Если делитель отрицательный, остаток все равно будет положительным.
Пример:
11 % 3 -11 % 3 11 % -3 -11 % -3
Модуль и остаточный оператор
Многие программисты путают модуль и оператор остатка. Некоторые языки программирования используют % как оператор модуля, а некоторые языки программирования используют % как оператор остатка.
Оператор модуля и оператор остатка дают один и тот же результат при выполнении деления с положительным числом. Разница между двумя типами операторов различается при работе с отрицательными числами.
См. пример ниже:
Ниже приведена оставшаяся операция с использованием Swift:
Ниже приведена операция модуля в Python 2.7 (доступна в Mac OS).
Как показано выше, если и делимое, и делитель положительны или отрицательны; оператор возвращает тот же результат.
Однако, если делимое или делитель отрицательны, результат будет другим.
Мы хотели бы проверить, когда делитель положителен; что произойдет с остатком, если мы перенесем делимое с положительного числа на отрицательное число.
Пример:
for i in -12…12 {
print(“\(i) % 3 is \(i % 3)”)
}
Результат выглядит следующим образом
Из операции с остатком мы знаем, что если дивиденд отрицательный, остаток будет отрицательным.
Для операции модуля, независимо от того, является ли делимое отрицательным или положительным, остаток всегда положителен. Кроме того, вычисление mod отличается от Swift, когда делимое отрицательно. Чтобы получить -11 % 3, Python использует формулу (-кратные x кратные) + модуль. В нашем примере кратное получается как -4 x 3 = -12. Следовательно, -12 + модуль = -11, таким образом, модуль равен 1. Обратите внимание, что модуль должен быть положительным. мы не можем использовать -9 и -2 (модуль) для получения -11.
Обратите внимание, что для языка программирования типа C, такого как C, C #, Java, JavaScript и Swift; реализация такая же. Языки программирования, такие как Python, Smalltalk, Perl, MATLAB, Haskell и Common LISP, используют другой тип реализации.
Также обратите внимание, что некоторые языки программирования предоставляют 2 разных типа реализации. В Python, чтобы реализовать оставшуюся операцию, аналогичную Swift или C, нам нужно использовать math.fmod.
Предыдущий раздел не является всесторонним исследованием различий между операцией остатка и модуля. Это просто напоминание программисту о том, что существуют различия между модулем и остатком, когда мы используем их для работы с отрицательными числами.
Остаток для числа с плавающей запятой
Чтобы использовать остаток для числа с плавающей запятой, мы можем использовать функцию остаток(_,_) или truncatingRemainder(dividingBy:)
Обе функции дают разные результаты. См. пример ниже»
Мы не будем рассматривать это подробно.
Унарный минус оператор
Мы можем преобразовать положительное число в отрицательное, используя унарный оператор минус (-). См. пример ниже:
Пример:
let a = 13 let b = -a let c = -b
Примечание. Мы используем унарный оператор минус для преобразования положительного числа в отрицательное. Мы также можем использовать тот же оператор для преобразования отрицательного числа в положительное число, как показано выше.
Унарный оператор плюс не имеет никакого эффекта в Swift.
Применение арифметического оператора
Пример:
let unitPrice = 25.5 let quantity = 12546 let deposit = 10034.80 let amount = unitPrice * Double(quantity) let discount = amount * 0.05 let discountAmount = -discount let payableAmount = amount + discountAmount
// Continuation from previous code let salesTax = payableAmount * 0.07 let totalAmount = payableAmount + salesTax let cashPayment = totalAmount — deposit let totalUnitCost = totalAmount / 12546
Составной оператор присваивания
Составной оператор присваивания, такой как += x, представляет собой краткую форму записи a = a + x. У нас есть следующий тип составного оператора присваивания:
- Сложение (+=) то же, что и a = a + x
- Вычитание (-=) аналогично а = а — х
- Умножение (*=) аналогично a = a * x
- Деление (/=) то же, что и = а/х
- Остаток (%=) такой же, как a = a % x
Пример:
var a = 10 a -= 1 a *= 2 a /= 2 a += 2 a %= 2
Примечание:
Составной оператор не возвращает значение.
Вы не можете использовать следующие
пусть var551 = var54 += 5
or
пусть var551 = (var54 += 5)
Пример:
var 54 = 10 //let var551 = (var54 += 5) // Will generate error warning
Оператор сравнения
Оператор сравнения сравнивает числа и возвращает результат, если тест верен. Ниже приведены операторы сравнения:
- Равно (==)
- Не равно (!=)
- Больше чем (›)
- Меньше чем (‹)
- Больше ИЛИ равно (›=)
- Меньше ИЛИ равно (‹=)
Каждое сравнение возвращает логическое значение.
Пример:
10 == 10 20 == 21 123 != 934 123 != 123 12476 > 887 12476 > 12476 12476 > 12477 768 < 409098 409098 < 409098 409099 < 409098
Пример 2:
1776 >= 1775 1776 >= 1776 1776 >= 1777 7172 <= 7173 7172 <= 7172 7172 <= 7171
Мы также можем сравнивать кортежи с кортежами. Сравнение работало путем сравнения каждого элемента слева направо. Для сравнения на равенство (==) система сравнивает крайний левый элемент с первым элементом справа; если он равен и результат верен, система продолжит сравнение второго элемента. Если оно не равно, система вернет false после первого сравнения и остановит операцию сравнения.
let originalTuples = ("a", 12, 2.78)
// Only true when all element is true
originalTuples == ("a",12,2.78)
originalTuples == ("A",12,2.78)
Точно так же для операции не равно (!=) система будет сравнивать каждый элемент. Если результат ложный (Равно), система будет сравнивать следующий элемент. Если результат сравнения истинен (не равно), система прекратит сравнение.
let originalTuples = ("z", 10, 2.788)
// Only false when all element is false
originalTuples != ("c",12,98)
originalTuples != ("z",10,2.788)
originalTuples != ("a",10,2.78)
// previous statement 2.78 is != 2.788
Мы можем использовать знак «больше» или «меньше» для сравнения элементов кортежей. Однако система вернет результат первого элемента, который не равен. Если первый элемент для обоих кортежей не равен, система вернет результат оценки первого элемента. Если оба первых элемента равны, то система вернет второй результат оценки и проигнорирует остальные.
let originalTuples = ("a", 14, 2.7888)
// For string or character it compares the ranking in the Unicode table
// b is greater than a
originalTuples > ("b", 14, 77.8)
// character "2" is smaller than "a", did not compare 55.8 vs 2.788
originalTuples > ("2", 14, 55.8)
// Return the last result since first 2 element is equal
originalTuples > ("a", 14, 0.8)
// Return the last result since first 2 element is equal
originalTuples > ("a", 14, 55.8)
// Return the second result since first element is equal, ignore last element
originalTuples > ("a", 56, 0.08)
// Return the second result since first element is equal, ignore last element
originalTuples > ("a", 3, 55.8)
Примечание:
Обратите внимание, что мы можем сравнивать не только числа, но и символы или строки. Однако мы не можем использовать знак больше или меньше для логических переменных. Использование знака больше вместо знака меньше чем для логических переменных приведет к ошибке. Для логических переменных мы можем использовать сравнение «равно» или «не равно».
Пример:
В следующих примерах показано сравнение кортежей с логическими переменными.
let someOriginalTuples = (true, false, 12) someOriginalTuples == (false, false,12) someOriginalTuples == (true, false, 12)
Если мы используем логическую переменную со знаком больше или меньше, это вызовет ошибку.
Важное примечание:
Оператор сравнения может сравнивать кортежи с 6 элементами или меньше. Если наши кортежи содержат 7 или более элементов, мы должны реализовать сравнение по отдельности.
Пример:
В следующем примере показано максимальное количество кортежей элементов, которые можно использовать для сравнения с оператором сравнения.
let someOriginalTuples3 = (1, 2, 3, 4, 5, 6) someOriginalTuples3 > (0, 1, 2, 3, 4, 5)
Пример:
В следующем примере показано неудачное сравнение, если мы сравниваем 7 или более элементов в кортежах.
Чтобы выполнить сравнение 7 элементов, используйте приведенный ниже пример:
let someOriginalTuples4 = (1, 2, 3, 4, 5, 6, 7) someOriginalTuples4.0 > 0 someOriginalTuples4.1 > 1 someOriginalTuples4.2 > 2 someOriginalTuples4.3 > 3 someOriginalTuples4.4 > 4 someOriginalTuples4.5 > 5 someOriginalTuples4.6 > 6
Тернарный условный оператор
Тернарный оператор состоит из 3 частей. Синтаксис следующий:
‹запрос›?‹ответ1›:‹ответ2›
Система оценит запрос, и если выражение окажется истинным, система вернет оценочное значение ответа1. Если запрос неверен, система вернет оценочное значение ответа2.
Тернарный оператор — это сокращенная версия следующего кода:
if query {
answer1
} else {
answer2
}
Пример:
var result = ""
let student1 = 65
result = student1 > 50 ? "pass" : "fail"
print("Student 1 \(result)")
Тернарный оператор аналогичен приведенному ниже коду:
var result = ""
let student1 = 65
if student1 > 50 {
result = "pass"
} else {
result = "fail"
}
print("Student 1 \(result)")
Поскольку тернарный оператор трудно понять, мы рекомендуем использовать его с умом и избегать объединения нескольких тернарных операций в один составной оператор.
Nil-объединяющий оператор
Оператор нулевого объединения (??) разворачивает значение необязательной переменной, если оно не равно нулю. Если необязательная переменная равна нулю, по умолчанию она будет равна второму предоставленному значению. Синтаксис следующий:
‹необязательная_переменная› ?? ‹value_used_when_optionl_is_nil›
Например, рассмотрим userDefineColor ?? цвет по умолчанию. Переменная userDefineColor является необязательной. Если в этой переменной есть значение, система развернет значение в этой переменной. Если, с другой стороны, эта переменная окажется нулевой, то система будет использовать значение defaultColor.
Всю конструкцию можно сформировать с помощью программы ниже:
if userDefineColor != nil {
colorUsed = userDefineColor
} else {
colorUsed = defaultColor
}
Пример:
let defaultColor = "red"
let userDefinedColor:String? = nil
let colorUsed = userDefinedColor ?? defaultColor
print("Color used is \(colorUsed).")
Если наш необязательный параметр содержит значение, то это значение будет развернуто и использовано.
let defaultColor = "red"
let userDefinedColor:String? = "green"
let colorUsed = userDefinedColor ?? defaultColor
print("Color used is \(colorUsed).")
Оператор диапазона
Существует три типа оператора диапазона: оператор закрытого диапазона, оператор полуоткрытого диапазона и оператор одностороннего диапазона.
Оператор закрытого диапазона
Оператор закрытого диапазона представлен (…). Оператор закрытого диапазона включает начальный номер и конечный номер. Чтобы использовать оператор закрытого диапазона, следуйте синтаксису:
‹begin_number›…‹end_number›
Пример:
Мы можем использовать оператор близкого диапазона для определения диапазона индекса, как показано в примере ниже:
for index in 1...10 {
print("Item: \(index)")
}
Оператор полуоткрытого диапазона
Оператор полуоткрытого диапазона представлен (..‹). Включает первое число и число меньше последнего числа (last_number — 1). Синтаксис следующий:
‹begin_number›..‹‹last_number›
Пример
for index in 1..<10 {
print("Item:\(index)")
}
Оператор полудиапазона полезен при ссылке на массивы или любой индекс данных, который начинается с 0 и заканчивается общим числом меньше единицы.
Пример:
let myArrays = [0,1,2,3,4,5,6,7,8,9]
let count = myArrays.count
for index in 0..<count {
print("Number: \(index)")
}
Применение операторов диапазона
Мы также можем использовать операторы диапазона в качестве индексов в массиве. Ниже приведен пример использования операторов диапазона с массивом.
let someArrayA = [1,2,3,4,5,6,7,8,9,10] someArrayA[0] someArrayA[9] someArrayA.count someArrayA.last someArrayA[3…7] someArrayA[3..<7]
Мы также можем определить диапазон и использовать его в любом другом контексте, кроме индексов:
// Define closed range
let someRange1 = 1…10
for index in someRange1 {
print(index)
}
// Print 1 to 10
// Define half open range
let someRange2 = 1..<16
for index in someRange2 {
print(index)
}
// Print 1 to 15
Односторонний оператор диапазона
Односторонний оператор диапазона — это оператор диапазона без начального или конечного номера. Его можно применить к любому оператору закрытого диапазона или оператору полуоткрытого диапазона.
Односторонний оператор ближнего боя
Односторонний оператор ближнего действия может быть записан как
...5 1...
Интерпретация одностороннего оператора такова:
- …5 — указать системе считать от начала индекса (может быть 0 или 1) до 5 включительно.
- 1… — указать системе считать от 1 до конца индекса.
Оператор одностороннего полуоткрытого диапазона
Односторонний оператор полуоткрытого диапазона может быть записан как
..<10
Для оператора полуоткрытого диапазона Swift поддерживает только односторонний оператор полуоткрытого диапазона с включенным конечным индексом, как показано выше.
Мы не можем сделать (0..‹), как показано на экране ниже.
Ниже приведен пример применения оператора одностороннего диапазона.
let someArrayB = [1,2,3,4,5,6,7,8,9,10] someArrayB[0] someArrayB[9] someArrayB.count someArrayB.last someArrayB[3…7] someArrayB[1…] someArrayB[…7] someArrayB[3..<7] someArrayB[..<5]
Предел оператора одностороннего диапазона
Мы также можем использовать односторонний оператор диапазона в любом другом контексте, кроме индексов массива. Однако, если диапазон односторонний, каковы пределы? Диапазон ограничен максимальным и минимальным целым числом.
См. пример ниже:
// Define range from 1 t0 maximum of an Int can handle let someRange3 = 1… someRange3.contains(100) someRange3.contains(100000000) let rangeMax = Int.max someRange3.contains(rangeMax) // Define range from Int minimum to 100 inclusive let someRange4 = …100 someRange4.contains(10000) someRange4.contains(100) someRange4.contains(-11000000) let rangeMin = Int.min someRange4.contains(rangeMin) // Define range from Int minimum to 100 inclusive let someRange5 = ..<1000 someRange5.contains(1000) someRange5.contains(999) someRange5.contains(-766999) someRange5.contains(rangeMin)
Обратите внимание, что если мы введем число, выходящее за пределы целого числа, произойдет ошибка времени выполнения или компиляции.
Логический оператор
В Swift мы поддерживаем 3 логических оператора: НЕ, И и ИЛИ.
- Оператор НЕ обозначается как !
- Оператор AND обозначается как &&
- Операция ИЛИ обозначается как ||
Логический оператор НЕ
Мы можем использовать логический оператор НЕ в качестве унарного префикса. НЕ перед истинным будет ложным и наоборот. Синтаксис использования оператора NOT следующий:
!‹переменная/данные›
Пример
let myTruth = false
let myNewTruth = !myTruth
print("My truth is \(myTruth) and my new truth is \(myNewTruth).")
Логический оператор И
Мы используем логический оператор И в качестве бинарного оператора между двумя операндами. Синтаксис использования оператора AND следующий:
‹переменная/данные› && ‹переменная/данные›
Пример
let myDoorCode = true
let myFingerPrint = false
if myDoorCode && myFingerPrint == true {
print("Access Granted")
} else {
print("Access Denied")
}
Примечание.
Обратите внимание, что для оператора И система использует оценку короткого замыкания. Это означает, что система будет оценивать крайний левый условный оператор, и если первая оценка будет ложной, система прекратит дальнейшую оценку, потому что даже если вторая оценка верна, результат все равно будет ложным. Мы должны поместить утверждение, которое обычно дает ложный результат, в левой части оценки, чтобы повысить эффективность.
Логический оператор ИЛИ
Мы используем логический оператор ИЛИ в качестве бинарного оператора между двумя операндами. Синтаксис использования оператора ИЛИ следующий:
‹переменная/данные› || ‹переменная/данные›
Пример:
let myFingerPrint = false
if myDoorCode || myFingerPrint == true {
print("Access Granted")
} else {
print("Access Denied")
}
Примечание.
Точно так же для оператора операционной система также использует оценку короткого замыкания. Это означает, что система будет оценивать крайний левый условный оператор, и если первая оценка верна, система остановит дальнейшую оценку, потому что даже если вторая оценка ложна, результат все равно будет истинным. Мы должны поместить утверждение, которое обычно дает истинный результат, в левую часть оценки, чтобы повысить эффективность.
Составной логический оператор
Мы используем множественный логический оператор для формирования составного выражения. Система сначала будет оценивать крайнее левое выражение, а затем — правое. Обратите внимание, однако, что && имеет приоритет над ||. Вам нужно оценить операцию && слева направо, а затем оценить || слева направо.
Пример:
let myDoorCode = true
let myFingerPrint = false
let keyOverride = true
let overridePassCode = true
if myDoorCode && myFingerPrint || keyOverride && overridePassCode {
print("Access Granted")
} else {
print("Access Denied")
}
В приведенном выше примере система позволила пользователю войти в ворота с помощью 2 комбинаций. Либо пользователь правильно вводит код двери вместе с правильным сканированием отпечатков пальцев, либо; пользователь может использовать ключ ручной блокировки вместе с правильным паролем блокировки.
Чтобы улучшить читаемость, приведенный выше пример следует написать следующим образом:
Оператор И имеет приоритет перед оператором ИЛИ
Пока мы строим составной оператор, имейте в виду, что оператор И имеет более высокий уровень приоритета по сравнению с оператором ИЛИ.
Пожалуйста, проверьте пример ниже:
// The following evaluate to true since AND has precedence over OR true || false && false // To produce the false result we must use () as shown below (true || false) && false
Еще пример:
let condition1 = true let condition2 = false let condition3 = true let condition4 = false condition1 || condition2 && condition3 && condition4 // Please note that && has precedence over || You need to evaluate && operation from left to right and then evaluate || from left to right
Пример:
true || false && true && false true && false || false || true true && true || false && false false || true && true || false
Приоритет оператора
Приоритет оператора — это порядок вычисления оператора. Рассмотрим пример ниже:
Пример:
42–20 * 12 / 3 + 5 * 6 + 54 // The result is 46
Для некоторых языков программирования все арифметические операторы имеют одинаковый приоритет; это означает, что система будет оценивать вычисление в порядке слева направо. Результат будет 612, если мы оцениваем слева направо.
Однако большинство языков программирования используют общий приоритет, когда умножение и деление имеют одинаковый приоритет, но они расположены в более высоком порядке, чем сложение и вычитание.
В приведенном выше примере мы должны сначала оценить умножение и деление слева направо. После оценки умножения и деления мы начинаем оценку сложения и вычитания слева направо.
Чтобы изменить порядок приоритета, например, мы хотим сначала выполнить вычитание, мы можем добавить круглые скобки, чтобы повлиять на порядок. Скобки имеют более высокий приоритет, чем другие арифметические операторы.
Пример:
42–20 * 12 / 3 + 5 * 6 + 54 (42–20) * 12 / 3 + 5 * (6 + 54)
В приведенном выше примере система сначала выполнит вычисление в скобках, прежде чем возобновить нормальную арифметическую операцию. Результат другой.
Точно так же мы также можем использовать круглые скобки, чтобы повлиять на порядок оценки, когда мы используем логический оператор, как показано в предыдущем разделе.
Ниже приведена упрощенная таблица приоритета оператора. Все операторы в одной группе имеют одинаковый приоритет. Левая ассоциативность означает, что система будет оценивать выражение слева направо. Правоассоциативный означает, что система будет оценивать выражение справа налево. Оператор в верхней части списка имеет более высокий приоритет, чем оператор в нижней части списка.
Явные скобки
Для сложного выражения лучше использовать скобки или круглые скобки для организации выражения. Это также улучшает читаемость кода.
Пример:
let condition5 = true let condition6 = false let condition7 = true let condition8 = false condition5 || condition6 && condition7 && condition8 // Evaluate to true as && take precedence before || // With parentheses the result may be different (condition5 || condition6) && (condition7 && condition8)
Первоначально опубликовано на сайте blog.swifticode.com 2 мая 2018 г.
