术语
运算符分为一元、二元和三元运算符:
- 一元运算符对单一操作对象操作（如
-a）。一元运算符分前置运算符和后置运算符，前置运算符需紧跟在操作对象之前（如 !b），后置运算符需紧跟在操作对象之后（如c!）。 - 二元运算符操作两个操作对象（如
2 + 3），是中置的，因为它们出现在两个操作对象之间。 - 三元运算符操作三个操作对象，和
C语言一样，Swift只有一个三元运算符，就是三目运算符（a ? b : c）。
受运算符影响的值叫操作数，在表达式 1 + 2 中，加号 + 是二元运算符，它的两个操作数是值 1 和 2。
赋值运算符
赋值运算符（a = b），表示用 b 的值来初始化或更新 a 的值：
let b = 10
var a = 5
a = b
// a 现在等于 10
let (x, y) = (1, 2)
// 现在 x 等于 1，y 等于 2
与 C 语言和 Objective-C 不同，Swift 的赋值操作并不返回任何值。所以下面语句是无效的：
if x = y {
// 此句错误，因为 x = y 并不返回任何值
}
算术运算符
Swift 中所有数值类型都支持了基本的四则算术运算符：
- 加法（+）
- 减法（-）
- 乘法（*）
- 除法（/）
1 + 2 // 等于 3
5 - 3 // 等于 2
2 * 3 // 等于 6
10.0 / 2.5 // 等于 4.0
加法运算符也可用于 String 的拼接：
"hello, " + "world" // 等于 "hello, world"
求余运算符
求余运算符（a % b）是计算 b 的多少倍刚刚好可以容入 a，返回多出来的那部分（余数）。
计算 9 % 4，你先计算出 4 的多少倍会刚好可以容入 9 中：
9 % 4 // 等于 1
为了得到 a % b 的结果，% 计算了以下等式，并输出 余数作为结果：
a = (b × 倍数) + 余数
同样的方法，我们来计算 -9 % 4：
-9 % 4 // 等于 -1
在对负数
b求余时，b的符号会被忽略。这意味着a % b和a % -b的结果是相同的。
一元负号运算符
一元负号符（-）写在操作数之前，中间没有空格。
let three = 3
let minusThree = -three // minusThree 等于 -3
let plusThree = -minusThree // plusThree 等于 3, 或 "负负3"
一元正号运算符
一元正号符（+）不做任何改变地返回操作数的值
组合赋值运算符
表达式 a += 2 是 a = a + 2 的简写，一个组合加运算就是把加法运算和赋值运算组合成进一个运算符里，同时完成两个运算任务。
var a = 1
a += 2
// a 现在是 3
注意
复合赋值运算没有返回值，let b = a += 2这类代码是错误。这不同于上面提到的自增和自减运算符。
比较运算符
Swift 支持以下的比较运算符：
- 等于（a == b）
- 不等于（a != b）
- 大于（a > b）
- 小于（a < b）
- 大于等于（a >= b）
- 小于等于（a <= b）
每个比较运算都返回了一个标识表达式是否成立的布尔值：
1 == 1 // true, 因为 1 等于 1
2 != 1 // true, 因为 2 不等于 1
2 > 1 // true, 因为 2 大于 1
1 < 2 // true, 因为 1 小于2
1 >= 1 // true, 因为 1 大于等于 1
2 <= 1 // false, 因为 2 并不小于等于 1
比较运算多用于条件语句，如 if 条件：
let name = "world"
if name == "world" {
print("hello, world")
} else {
print("I'm sorry (name), but I don't recognize you")
}
// 输出“hello, world", 因为 `name` 就是等于 "world”
如果两个元组的元素相同，且长度相同的话，元组就可以被比较。比较元组大小会按照从左到右、逐值比较的方式，直到发现有两个值不等时停止。如果所有的值都相等，那么这一对元组我们就称它们是相等的。例如：
(1, "zebra") < (2, "apple") // true，因为 1 小于 2
(3, "apple") < (3, "bird") // true，因为 3 等于 3，但是 apple 小于 bird
(4, "dog") == (4, "dog") // true，因为 4 等于 4，dog 等于 dog
注意
Swift 标准库只能比较七个以内元素的元组比较函数。如果你的元组元素超过七个时，你需要自己实现比较运算符
三元运算符
三元运算符的特殊在于它是有三个操作数的运算符，它的形式是 问题 ? 答案 1 : 答案 2。它简洁地表达根据 问题成立与否作出二选一的操作。如果 问题 成立，返回 答案 1 的结果；反之返回 答案 2 的结果。
let contentHeight = 40
let hasHeader = true
let rowHeight = contentHeight + (hasHeader ? 50 : 20)
// rowHeight 现在是 90
三元运算符是以下代码的缩写形式：
if question {
answer1
} else {
answer2
}
空合运算符
空合运算符（a ?? b）将对可选类型 a 进行空判断，如果 a 包含一个值就进行解包，否则就返回一个默认值 b。表达式 a 必须是 Optional 类型。默认值 b 的类型必须要和 a 存储值的类型保持一致。
空合运算符是对以下代码的简短表达方法：
a != nil ? a! : b
上述代码使用了三元运算符。当可选类型 a 的值不为空时，进行强制解包（a!），访问 a 中的值；反之返回默认值 b。无疑空合运算符（??）提供了一种更为优雅的方式去封装条件判断和解包两种行为，显得简洁以及更具可读性。
注意
如果a为非空值（non-nil），那么值b将不会被计算。这也就是所谓的短路求值。
下文例子采用空合运算符，实现了在默认颜色名和可选自定义颜色名之间抉择：
let defaultColorName = "red"
var userDefinedColorName: String? //默认值为 nil
var colorNameToUse = userDefinedColorName ?? defaultColorName
// userDefinedColorName 的值为空，所以 colorNameToUse 的值为 "red"
区间运算符
闭区间运算符
闭区间运算符（a...b）定义一个包含从 a 到 b（包括 a 和 b）的所有值的区间。a 的值不能超过 b。
for index in 1...5 {
print("(index) * 5 = (index * 5)")
}
// 1 * 5 = 5
// 2 * 5 = 10
// 3 * 5 = 15
// 4 * 5 = 20
// 5 * 5 = 25
半开区间运算符
半开区间运算符（a..<b）定义一个从 a 到 b 但不包括 b 的区间。 之所以称为半开区间，是因为该区间包含第一个值而不包括最后的值。
let names = ["Anna", "Alex", "Brian", "Jack"]
let count = names.count
for i in 0..<count {
print("第 (i + 1) 个人叫 (names[i])")
}
// 第 1 个人叫 Anna
// 第 2 个人叫 Alex
// 第 3 个人叫 Brian
// 第 4 个人叫 Jack
单侧区间
闭区间操作符有另一个表达形式，可以表达往一侧无限延伸的区间 —— 例如，一个包含了数组从索引 2 到结尾的所有值的区间。在这些情况下，你可以省略掉区间操作符一侧的值。这种区间叫做单侧区间，因为操作符只有一侧有值。例如：
let names = ["Anna", "Alex", "Brian", "Jack"]
for name in names[2...] {
print(name)
}
// Brian
// Jack
for name in names[...2] {
print(name)
}
// Anna
// Alex
// Brian
半开区间操作符也有单侧表达形式，附带上它的最终值。就像你使用区间去包含一个值，最终值并不会落在区间内。例如：
for name in names[..<2] {
print(name)
}
// Anna
// Alex
单侧区间不止可以在下标里使用，也可以在别的情境下使用。你不能遍历省略了初始值的单侧区间，因为遍历的开端并不明显。你可以遍历一个省略最终值的单侧区间；然而，由于这种区间无限延伸的特性，请保证你在循环里有一个结束循环的分支。你也可以查看一个单侧区间是否包含某个特定的值，就像下面展示的那样。
let range = ...5
range.contains(7) // false
range.contains(4) // true
range.contains(-1) // true
逻辑运算符
逻辑运算符的操作对象是逻辑布尔值。Swift 支持基于 C 语言的三个标准逻辑运算。
- 逻辑非（
!a） - 逻辑与（
a && b） - 逻辑或（
a || b）
逻辑非运算符
逻辑非运算符（!a）对一个布尔值取反，使得 true 变 false，false 变 true。
它是一个前置运算符，需紧跟在操作数之前，且不加空格。读作 非 a ，例子如下：
let allowedEntry = false
if !allowedEntry {
print("ACCESS DENIED")
}
// 输出“ACCESS DENIED”
逻辑与运算符
逻辑与运算符（a && b）表达了只有 a 和 b 的值都为 true 时，整个表达式的值才会是 true。
let enteredDoorCode = true
let passedRetinaScan = false
if enteredDoorCode && passedRetinaScan {
print("Welcome!")
} else {
print("ACCESS DENIED")
}
// 输出“ACCESS DENIED”
逻辑或运算符
逻辑或运算符（a || b）是一个由两个连续的 | 组成的中置运算符。它表示了两个逻辑表达式的其中一个为 true，整个表达式就为 true。
let hasDoorKey = false
let knowsOverridePassword = true
if hasDoorKey || knowsOverridePassword {
print("Welcome!")
} else {
print("ACCESS DENIED")
}
// 输出“Welcome!”
逻辑运算符组合计算
if enteredDoorCode && passedRetinaScan || hasDoorKey || knowsOverridePassword {
print("Welcome!")
} else {
print("ACCESS DENIED")
}
// 输出“Welcome!”
注意
Swift 逻辑操作符 && 和 || 是左结合的，这意味着拥有多元逻辑操作符的复合表达式优先计算最左边的子表达式。
使用括号来明确优先级
if (enteredDoorCode && passedRetinaScan) || hasDoorKey || knowsOverridePassword {
print("Welcome!")
} else {
print("ACCESS DENIED")
}
// 输出“Welcome!”
这括号使得前两个值被看成整个逻辑表达中独立的一个部分。虽然有括号和没括号的输出结果是一样的，但对于读代码的人来说有括号的代码更清晰。可读性比简洁性更重要，请在可以让你代码变清晰的地方加个括号吧！