运算符是检查、改变、合并值的特殊符号或短语。例如，加号（ + ）将两个数相加（如 let i = 1 + 2）。 更复杂的运算例子包括逻辑与运算符 && （如 if enteredDoorCode && passedRetinaScan ）。

　　Swift 支持大部分标准 C 语言的运算符，且改进许多特性来减少常规编码错误。如：赋值符（ = ）不返回值，以 防止把想要判断相等运算符（ == ）的地方写成赋值符导致的错误。算术运算符（ + ， - ， * ， / ， % 等）会 检测并不允许值溢出，以此来避免保存变量时由于变量大于或小于其类型所能承载的范围时导致的异常结果。当然允许你使用 Swift 的溢出运算符来实现溢出。

　　Swift 还提供了 C 语言没有的表达两数之间的值的区间运算符（ a..<b 和 a...b），这方便我们表达一个区间内的数值。

　　本章节只描述了 Swift 中的基本运算符，高级运算符这章会包含 Swift 中的高级运算符，及如何自定义运算符，及如何进行自定义类型的运算符重载。

　　术语

　　运算符分为一元、二元和三元运算符：

　　一元运算符对单一操作对象操作（如 -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 语句中使用是错误的：

　　if x = y {

　　// 此句错误，因为x = y 并不返回任何值

　　}

　　这个特性使你无法把（==）错写成（=），由于 if x = y 是错误代码，swift 能帮你避免此类错误发生。

　　算数运算符

　　swift 中所有数值类型都支持了基本的四则算术运算符：

　　加法（+）

　　减法（-）

　　乘法（*）

　　除法（／）

　　与 C 语言和 Objective-C 不同的是，swift 默认情况下不允许在数值运算中出现溢出情况。但是你可以使用 swift 的溢出运算符来实现溢出运算（如 a &+ b）。

　　加法运算符也可用于 string 的拼接：

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

　　求余运算符

　　求余运算符（a % b）是计算 b 的多少倍刚刚好可以容入 a, 返回多出来的那部分（余数）。

　　注意：

　　求余运算符（%）在其他语言中叫取模运算符。然而严格说来，我们看该运算符对负数的操作结果，求余比取模更合适些。

　　来谈谈取余是怎么回事，计算 9 % 4 ，你先计算出 4 的多少倍会刚好可以容入 9 中：

　　可以在 9 中放入两个 4 ，那余数是 1 。

　　在 swift 中可以表达为：

　　9 % 4 // 等于1

　　为了得到 a % b 的结果， % 计算了以下等式，并输出 余数 作为结果。

　　a = (b * 倍数) + 余数

　　当倍数取最大值的时候，就会刚好可以容入 a 中。

　　把 9 和 4 带入等式中，我们得到 1 ：

　　9 = （4 * 2） + 1

　　同样的方法，我们计算 -9 % 4:

　　-9 % 4 // 等于 -1

　　把 -9 和 4 代入等式，-2 是取到的最大整数：

　　-9 = （4 * -2） + -1

　　余数是 -1。

　　在对负数 b 求余时，b 的符号会被忽略。这意味着 a % b 和 a % -b 的结果是一样的。

　　一元负号运算符

　　数值的正负号可以使用前缀 - （即一元负号符）来切换：

　　let three = 3

　　let minusThree = -three // minusThree 等于 -3

　　let plusThree = -minusThree // plusThree 等于 3，或 “负负3”

　　一元负号符（-） 写在操纵数之前，中间没有空格。

　　一元正号运算符

　　一元正号符（+）不做任何改变的返回操作数的值：

　　let minusSix = -6

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

　　虽然一元正号符什么都不会改变，但当你在使用一元负号来表达负数时，你可以使用一元正号来表达正数。

　　组合赋值运算符

　　如同 C 语言，swift 也提供把其他运算符和赋值运算符（=）组合的组合赋值运算符，组合加运算（+=）是其中一个例子：

　　var a = 1

　　a += 2

　　// a 现在是 3

　　表达式 a += 2 是 a = a + 2 的简写，一个组合加运算就是把加法运算和赋值运算组合成进一个运算符里，同时完成两个运算任务。

　　注意：

　　复合赋值运算没有返回值，let b = a += 2 这类代码有错误。这不同于上面提到的自增和自减运算符。

　　比较运算符（comparison Operators）

　　所有标准 C 语言中的比较运算符都可以在 swift 中使用：

　　等于（==）

　　不等于（!=）

　　大于（>）

　　小于（<）

　　大于等于（>=）

　　小于等于（<=）

　　注意：

　　swift 也提供恒等（===）和不恒等（!==）这两个比较符类判断两个对象是否引用同一个对象实例。

　　每个比较运算符都返回了一个标识表达式是否成立的布尔值：

　　1 == 1 // true

　　2 != 1 // true

　　2 < 1 // false 

　　...

　　比较运算符多用于条件语句中，如 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”

　　当元组中的值可以比较时，你也可以使用这些运算符来比较它们的大小。例如，因为 Int 和 String 类型的值可以比较，所以类型为（Int, String）的元组也可以比较。相反，Bool 不能被比较，也意味着存在有布尔类型的元组不能被比较。

　　比较元组大小会按照从左至右、逐值比较的方式，直到发现有两个不等时停止。如果所有的值都相等，那么这一对元组我们就称它们是相等的。例如：

　　（1, "zebra"）< (2, "apple") // ture 2 > 1

　　(3, "apple") < (3, "bird") // true apple < bird

　　(4, "dog") == (4, "dog") // ture

　　在上面的例子中，你可以看到，在第一行中从左至右的比较行为。因为 1 小于 2，所以（1, "zebra"）小于 （2，"apple"）, 不管元组剩下的值如何。所以 “zebra” 小于 "apple" 没有任何影响，因为元组的比较已经被第一个元素决定了。不过，当元组的第一个元素相同时候，第二个元素将会用作比较，第二行和第三行代码就发生了这样的比较。

　　注意：

　　swift 标准库只能比较七个以内元素的元组比较函数。如果你的元组元素超过七个时，你需要自己实现比较运算符。

　　三目运算符（Ternary Conditional Operator）

　　三目运算符的特殊在于它是有三个操作数的运算符，它的形式是 问题？答案1: 答案2。它简洁地表达根据 问题 成立与否作出二选一的操作。如果问题成立，返回答案1的结果，反之返回 答案2 的结果。

　　三目运算符是以下代码的缩写形式：

　　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”

　　userDefinedColorName 变量被定义为一个可选的 String 类型，默认值为 nil。由于 userDefinedColorName 是一个可选类型，我们可以使用空合运算符去判断其值。在上一个例子中，通过空合运算符为一个名为 colorNameToUse 的变量赋予一个字符串类型初始值。由于 userDefinedColorName 值为空，因此表达式 userDefinedColorName ?? defaultColorName 返回 defaultColorName 的值，即 red。

　　另一情况，分配一个非空值（non-nil）给 userDefinedColorName，再次执行空合运算，运算结果为封包在 userDefaultColorName 中的值，而非默认值。

　　userDefinedColorName = "green"

　　colorNameToUse = userDefinedColorName ?? defaultColorName 

　　区间运算符（Range Operators）

　　swift 提供了两个方便表达一个区间的值的区间运算符。

　　闭区间运算符

　　闭区间运算符（a...b）定义了一个从 a 到 b （包括 a 和 b ）的所有值的区间。a 的值不能超过 b。闭区间运算符在迭代一个区间的所有值时是非常有用的，如在 for-in 循环中：

　　for index in 1...5 {

　　　　print("\(index) * 5 = \(index * 5)")

　　}

　　半开区间运算符

　　半开区间运算符（a..<b）定义一个从 a 到 b 但不包括 b 的区间。之所以称为半开区间，是因为该区间包含第一个值而不包括最后一个值。

　　半开区间的实用性在于当你使用一个从 0 开始的列表（如数组）时，非常方便地从 0 数到列表的长度。

　　let names = ["Anna", "Alex", "Brian", "Jack"]

　　let count = names.count

　　for i in 0..< count {

　　　　print("第 \(i + 1) 个人叫\(names[i])")

　　}

　　数组有 4 个元素，但 0..<count 只数到 3 （最后一个元素的下标），因为它是半开区间。

　　逻辑运算符

　　逻辑运算符的操作对象是逻辑布尔值。swift 支持基于 C 语言的三个标准逻辑运算符。

　　逻辑非 （!a）

　　逻辑与 （a && b）

　　逻辑或 （a || b）

　　逻辑非运算符

　　逻辑非运算符（!a）对一个布尔值取反，使得 true 变 false ,false 变 true。

　　它是一个前置运算符，需紧跟在操作数之前，且不加空格。读作 非a, 例子如下:

　　let allowedEntry = false

　　if !allowedEntry {

　　　　print("ACCESS DENIED")

　　}

　　if !allowedEntry 语句可以读作 如果 非 allowedEntry ，接下一行代码只有在 非allowedEntry 为 true, 即 allowEntry 为 false 时被执行。

　　在实例代码中，小心地选择布尔常量或变量有助于代码的可读性，并且避免使用双重逻辑非运算，或混乱的逻辑语句。

　　逻辑与运算

　　逻辑与运算符（a && b）表达了只有 a 和 b 的值都为 true 时，整个表达式的值才会是 true。

　　只要任意一个值为 false，整个表达式的值就为 false。事实上，如果第一个值为 false，那么是不去计算第二个值的。因为它已经不可能影响整个表达式的结果了。这种被称作短路运算（short-circuit evaluation）。

　　逻辑或运算符

　　逻辑或运算符（a || b）是一个由两个 || 组成的中置运算符。它表示了两个逻辑表达式的其中一个为 true ，整个表达式就为 true。

　　同逻辑与运算符类似，逻辑或也是 短路计算 的，当左端的表达式为 true 时，将不计算右边的表达式了，因为它不可能改变整个表达式的值了。

　　逻辑运算符组合计算

　　我们可以组合多个逻辑运算符来表达一个复合逻辑：

　　if enteredDoorCode && passedRetinaScan || hasDoorKey || KnowOverridePassword {

　　　　print("Welcome!")

　　} else {

　　　　print("ACCESS DENIED")

　　}

　　这个例子使用了含多个 && 和 || 的复合逻辑。但无论怎样，&& 和 || 始终只能操作两个值。所以这实际是三个简单逻辑连续操作的结果。

　　swift 逻辑操作符 && 和 || 是左结合的，这意味着拥有多元逻辑操作符的复合表达式优先计算最左边的子表达式。

　　使用括号来明确优先级

　　为了一个复杂表达式更容易读懂，在合适的地方使用括号来明确优先级是很有效的，虽然它并非必要的，在上个关于门的权限的例子中，我们给第一个部分加个括号，使它看起来逻辑更明确：

　　if (enteredDoorCode && passedRetinaScan) || hasDoorKey || knowsOverridePassword {

　　　　print("Welcome!")

　　} else {

　　　　print("ACCESS DENIED")

　　}

　　这括号使得前两个值被看成整个逻辑表达中独立的一个部分。虽然有括号和没括号的输出结果是一样的，但对于读代码的人来说有括号的代码更清晰。可读性比简洁性更重要。

END