本章介绍了 Swift 中的常见运算符。 涵盖了 Swift 的高级运算符，并描述了如何定义自定义运算符以及为自定义类型实现标准运算符。

术语

运算符可以是一元、二元或三元：

运算符影响的值称为操作数。在表达式 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 语言规定 if x = y 这种写法是无效的，这个特性可以防止不小心使用赋值运算符（=） 而非等于运算符（==）。Swift 帮助你避免代码中出现这种错误。

算术运算符

Swift 为所有数值类型支持四种标准算术运算符：

1 + 2       // 等于 3
5 - 3       // 等于 2
2 * 3       // 等于 6 
10.0 / 2.5  // 等于 4.0

Swift 的算术运算符与 C 和 Objective-C 中的不同，默认情况下不允许值溢出。您可以选择使用 Swift 的溢出运算符（如 a &+ b）来启用值溢出行为。请参阅 。

加法运算符也支持 String 拼接：

"hello, " + "world"  // 等于 "hello, world"

余数运算符

余数运算符（a % b）计算出 b 在 a 中能容纳多少个倍数，并返回剩余的值（称为余数）。

让我们来看看余数运算符是如何工作的。 要计算 9 % 4，首先要确定 9 中可以包含多少个 4：

我们可以在 9 中容纳两个 4，剩余的是 1（用橙色表示）。

在 Swift 中，这可以写作：

9 % 4    // 等于 1

为了确定 a % b 的答案，% 运算符计算以下等式并返回 余数 作为输出：

a = (b x 某个乘数) + 余数

其中 某个乘数 是 b 在 a 中能容纳的最大倍数。

将 9 和 4 代入此等式，得：

9 = (4 x 2) + 1

当计算 a 为负值时，采用相同的方法：

-9 % 4   // 等于 -1

将 -9 和 4 代入等式，得：

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

因此余数值为 -1。

对于 b 为负值的情况，其符号将被忽略。这意味着 a % b 和 a % -b 总是给出相同的答案。

一元负号运算符

数值的正负号可以使用前缀 - 切换，称为一元负号运算符：

let three = 3
let minusThree = -three       // minusThree 等于 -3
let plusThree = -minusThree   // plusThree 等于 3，或 "负负三"

一元负号运算符（-）直接加在它所作用的值前面，中间没有任何空格。

一元正号运算符

一元正号运算符（+）只是返回它所作用的值，不做任何改变：

let minusSix = -6
let alsoMinusSix = +minusSix  // alsoMinusSix 等于 -6  

虽然一元加运算符实际上什么也没做，但是当你使用一元减运算符表示负数时，你可以使用它来使你的代码对正数也保持对称性。

复合赋值运算符

与 C 语言一样，Swift 提供了复合赋值运算符，它将赋值（=）与另一个操作结合起来。 一个例子是加法赋值运算符（+=）：

var a = 1
a += 2
// a 现在等于 3

表达式 a += 2 是 a = a + 2 的简写。 实际上，加法和赋值被合并成一个同时执行这两个任务的运算符。

有关 Swift 标准库提供的运算符的信息，请参阅 Operator Declarations。

比较运算符

Swift 支持以下比较运算符：

每个比较运算符都返回一个 Bool 值来指示语句是否为真：

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"。

关于 if 语句的更多信息，请参阅 。

如果两个元组具有相同的类型和相同数量的值，则可以比较它们。 元组是从左到右逐个值进行比较的，直到比较发现两个不相等的值为止。 这两个值将进行比较，并且该比较的结果决定了整个元组比较的结果。 如果所有元素都相等，那么这两个元组本身就相等。 例如：

(1, "zebra") < (2, "apple")   // 为 true，因为 1 小于 2; "zebra" 和 "apple" 未比较
(3, "apple") < (3, "bird")    // 为 true，因为 3 等于 3，而 "apple" 小于 "bird"
(4, "dog") == (4, "dog")      // 为 true，因为 4 等于 4，而 "dog" 等于 "dog"

在上面的示例中，您可以看到第一行的从左到右比较行为。 因为 1 小于 2，所以 (1, "zebra") 被认为小于 (2, "apple")，而不管元组中的任何其他值如何。 即使 "zebra" 不小于 "apple"，也无关紧要，因为比较已经由元组的第一个元素决定了。 但是，当元组的第一个元素相同时，它们的第二个元素会进行比较 —— 这就是第二行和第三行发生的情况。

只有当给定的运算符可以应用于各自元组中的每个值时，元组才能与该运算符进行比较。例如，如下面的代码所示，您可以比较两个类型为 (String, Int) 的元组，因为 String 和 Int 值都可以使用 < 运算符进行比较。相反，类型为 (String, Bool) 的两个元组不能使用 < 运算符进行比较，因为 < 运算符不能应用于 Bool 值。

("blue", -1) < ("purple", 1)        // 可以，计算结果为 true
("blue", false) < ("purple", true)  // 错误，因为 < 不能比较布尔值

三元条件运算符

三元条件运算符是一种特殊的运算符，用于根据给定条件选择两个值中的一个。它由三个部分组成，语法格式为问题 ? 答案1 : 答案2。它根据问题的真假值来选择计算哪个表达式，并返回该表达式的值。如果问题为真，它会计算答案1并返回其值;否则，它会计算答案2并返回其值。

三元条件运算符是以下代码的简写形式：

if question {
    answer1
} else {
    answer2
}

下面是一个例子，用于计算表格行的高度。如果该行有标题，则行高应比内容高度高 50 点；如果该行没有标题，则行高应比内容高度高 20 点：

let contentHeight = 40
let hasHeader = true
let rowHeight = contentHeight + (hasHeader ? 50 : 20)
// rowHeight 等于 90

上面的例子是下面代码的简写形式：

let contentHeight = 40
let hasHeader = true
let rowHeight: Int
if hasHeader {
    rowHeight = contentHeight + 50
} else {
    rowHeight = contentHeight + 20
}
// rowHeight 等于 90

第一个例子使用三元条件运算符意味着rowHeight可以在一行代码中设置为正确的值，这比第二个例子中使用的代码更加简洁。

三元条件运算符提供了一种有效的简写方式来决定考虑两个表达式中的哪一个。不过，要谨慎使用三元条件运算符。如果过度使用，代码的可读性会下降。避免将多个三元条件运算符实例组合成一个复合语句。

空合并运算符

空合并运算符（a ?? b）如果可选项a包含一个值，则会解包该值，否则会返回默认值b（如果a为nil）。表达式a始终是一个可选类型。表达式b必须与存储在a中的类型相匹配。

空合并运算符是以下代码的简写形式：

a != nil ? a! : b

上面的代码使用三元条件运算符和强制解包（a!）来访问 a 中包装的值（当 a 不是 nil 时），否则返回 b。空合并运算符提供了一种更优雅的方式，以简洁和可读的形式封装这种条件检查和解包。

下面的示例使用空合并运算符在默认颜色名称和可选用户定义的颜色名称之间进行选择：

let defaultColorName = "red"
var userDefinedColorName: String?   // 默认为 nil

var colorNameToUse = userDefinedColorName ?? defaultColorName
// userDefinedColorName 为空，所以 colorNameToUse 为默认值 "red"

变量 userDefinedColorName 被定义为一个可选的 String 类型，默认值为 nil。由于 userDefinedColorName 是一个可选类型，你可以使用空合并运算符来考虑它的值。在上面的例子中，该运算符被用于确定一个名为 colorNameToUse 的 String 变量的初始值。因为 userDefinedColorName 是 nil，所以表达式 userDefinedColorName ?? defaultColorName 返回 defaultColorName 的值，即 "red"。

如果你给 userDefinedColorName 赋予一个非 nil 的值，并再次执行 nil 合并运算符检查，那么 userDefinedColorName 包裹的值将被使用，而不是默认值：

userDefinedColorName = "green" 
colorNameToUse = userDefinedColorName ?? defaultColorName
// userDefinedColorName 不是 nil，所以 colorNameToUse 被设置为 "green"

区间运算符

Swift 包含几个区间运算符，这些是表达一个值范围的快捷方式。

闭区间运算符

闭区间运算符（a...b）定义了一个从 a 到 b 的范围，包括 a 和 b 的值。a 的值不能大于 b。

闭区间运算符在需要使用所有值的情况下很有用，例如在 for-in 循环中：

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

更多关于 for-in 循环的内容，请参阅 。

半开区间运算符

半开区间运算符（a..）定义了一个从 a 到 b 但不包括 b 的范围。它被称为半开是因为它包含第一个值但不包含最后一个值。与闭区间运算符一样，a 的值不能大于 b。如果 a 等于 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

let allowedEntry = false
if !allowedEntry {
    print("ACCESS DENIED")
} // 打印 "ACCESS DENIED"

let enteredDoorCode = true
let passedRetinaScan = false
if enteredDoorCode && passedRetinaScan {
    print("Welcome!")
} else {
    print("ACCESS DENIED")
} // 打印 "ACCESS DENIED"

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!"

if (enteredDoorCode && passedRetinaScan) || hasDoorKey || knowsOverridePassword {
    print("Welcome!")
} else {
    print("ACCESS DENIED")
} // 打印 "Welcome!"