操作符就是一些专用的符号或短语，用于值的检查、更改、合并等。例如加号操作符+ 将两个数加起来（as in let i = 1 + 2）。更复杂的例子如逻辑与AND操作符&& （as in if enteredDoorCode && passedRetinaScan）和增值操作符++i，方便的给指定变量i 的值加1
Swift支持大多数标准 C 操作符，并改进了几个功能用以消除常见的编码错误。赋值操作符 = 不返回值，可防止在使用等于操作符 == 时错误地使用了赋值操作符。数学操作符（+, -, *, / % 等）会检测并阻止溢出，以避免出现超出类型允许存储范围的意外结果。使用Swift的溢出操作符，可以选择值溢出的行为，进一步的信息请看溢出操作符
与 C 不同的是，Swift允许浮点数进行取余（%）运算。还提供了两个 C 没有的范围操作符（a..<b 和 a...b），用于简便地表示范围内的值
这章主要讲述Swift的常用操作符。其他高级操作符请看高级操作符，在那章里主要讲怎样自定义操作符和为自定义类实现标准操作符
术语 Terminology
操作符分为一元（unary）、二元（binary）、三元（ternary）操作符：
- 一元操作符只作用于一个目标/操作数（如
-a）。一元前缀操作符紧挨在操作数前（例如!b），一元后缀操作符紧挨在操作数的后面（例如i++） - 二元操作符有两个操作数（如
2 + 3），并在两个操作数中间，是中缀操作符 - 三元操作符有三个操作数。和 C 一样，Swift只有一个三元操作符：条件操作符（
a ? b : c）
操作符使用的值就叫操作数。在表达式 1 + 2中，+ 加号是二元操作符，而他的两个操作数是 1 和 2
赋值操作符 Assignment Operator
赋值操作符（a = b）使用 b 的值初始化或更新 a 的值
<pre><code>
let b = 10
var a = 5
a = b
// a is now equal to 10
</code></pre>
如果赋值操作符右侧是一个有多个值的元组，其元素的值可以分解到多个常量或变量中：
<pre><code>
let (x, y) = (1, 2)
// x is equal to 1, and y is equal to 2
</code></pre>
与 C 和 Objective-C 不同，赋值操作符本身不返回值，所以下面对语句是无效的：
<pre><code>
if x = y {
// this is not valid, because x = y does not return a value
}
</code></pre>
这个特性会防止将相等操作符（==），意外写成赋值操作符（=）。因为 if x = y 无效，所以Swift将帮助你避免代码中的此类问题。
算数操作符 Arithmetic Operators
Swift的所有数字类型都支持4种标准的算数操作符：
- 加（
+） - 减（
-） - 乘（
*） - 除（
/）
<pre><code>
1 + 2 // equals 3
5 - 3 // equals 2
2 * 3 // equals 6
10.0 / 2.5 // equals 4.0
</code></pre>
不同于 C 和 Objective-C 的算数操作符，Swift算数操作符默认不允许值溢出。可以使用Swift的溢出操作符选择溢出行为（如 a &+ b）。详情请看溢出操作符
加号操作符同时也支持 String 连结：
<pre><code>
"hello, " + "world" // equals "hello, world"
</code></pre>
取余操作符 Remainder Operator
取余操作符（a % b）算出 a 能容纳多少个 b，并返回剩下的值（即：余数）
注：取余操作符在其他语言中也有的叫取模操作符。不过严格来说，在Swift中对于负数而言是余数而不是模操作
下图演示取余操作符如何计算的。 计算 9 % 4，首先要算出 9 里面有多少个 4：
整数计算余数
可以看出，这里有两个 4，最后剩余 1（图中黄色的部分）
中Swift中，取余操作符使用方法如下：
<pre><code>
9 % 4 // equals 1
</code></pre>
要确定 a % b 的答案，% 操作符计算如下等式并返回 remainder：
a = (b x some multiplier) + remainder
some multiplier是最大的乘以 b 仍能容纳于 a 的数
将 9 和 4 代入等式，产出：
9 = (4 x 2) + 1
同样，负数也使用此方法计算余数
<pre><code>
-9 % 4 // equals -1
</code></pre>
将 -9 和 4 代入等式，产出：
-9 = (4 x -2) + -1
余数是 -1
some multiplier如果是负数，将会忽视其符号。意思是 a % b 和 a % -b 将返回相同的结果
浮点数余数计算 Floating-Point Remainder Calculations
不同于 C 和 Objective-C 的取余操作符，Swift的取余操作符可以计算浮点数的余数：
<pre><code>
8 % 2.5 // equals 0.5
</code></pre>
浮点数计算余数
增量和减量操作符 Increment and Decrement Operators
与 C 类似，Swift也提供了增量操作符（++）和减量操作符（--），方便的对数值进行加/减 1 操作，可以用于整数和浮点数变量
<pre><code>
var i = 0
++i // i now equals 1
</code></pre>
每调用 ++i 一次，i 的值增加 1，本质上说，++i 是 i = i + 1 的简写。类似地，--i 可以是 i = i - 1 的简写
++ 和 -- 即可以用作前缀操作符，也可以用作后缀操作符。++i 与 i++ 都可以使 i 的值加 1。类似地，--i 与 i-- 都可以使 i 值减 1
注意，这两个操作符即修改 i 的值，也返回值。如果只是想 i 加/减 1，可以忽略返回值。然而，如果想使用返回值，那么前缀和后缀操作符会返回不同的值，规则如下：
- 如果操作符在变量前，则先改变变量值，并返回改变后的值
- 如果操作符中变量后，则先返回变量原值，后改变变量的值
<pre><code>
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
</code></pre>
除非你需要以 i++ 的方式使用操作符，否则推荐在所有的情况下使用 ++i 与 --i 的形式，因为返回值与实际值是相同的。
一元负号操作符 Unary Minus Operator
使用 - 操作符（前缀操作符）可以每次切换数值的符号，这就是负号操作符
<pre><code>
let three = 3
let minusThree = -three // minusThree equals -3
let plusThree = -minusThree // plusThree equals 3, or "minus minus three"
</code></pre>
负号操作符需要紧挨在操作数前面，之间不能有任何空白字符
一元正号操作符 Unary Plus Operator
使用 + 操作符，将会返回原值，而且对原值不会产生任何影响
<pre><code>
let minusSix = -6
let alsoMinusSix = +minusSix // alsoMinusSix equals -6
</code></pre>
虽然 + 操作符没有做任何事情，不过在代码中，对正数使用 + 操作符和对负数使用 - 操作符能使代码看起来比较整齐
组合赋值操作符 Compound Assignment Operators
像 C 一样，Swift提供了组合赋值操作符，将 = 与其他操作符组合在一起使用：
<pre><code>
var a = 1
a += 2
// a is now equal to 3
</code></pre>
表达式 a += 2 使 a = a + 2 的简写。将加法与赋值组合进一个操作符，这两个操作将同时执行。
注：组合赋值操作符不返回值。这点与上面提及的
++和--不同
要查看所有的组合赋值操作符，请看Swift Language Reference 之 表达式
比较操作符 Comparison Operators
Swift 支持所有标准 C 比较操作符：
- 等于 (
a == b) - 不等于 (
a != b) - 大于 (
a > b) - 小于 (
a < b) - 大于等于 (
a >= b) - 小于等于 (
a <= b)
注：Swift还提供了两个辨识操作符（
===、!==），用来比较两个对象引用是否是指向同一个对象实例，更多信息请参考类与结构
每个比较操作符都返回 Bool 值，指示语句是否为 true：
<pre><code>
1 == 1 // true, because 1 is equal to 1
2 != 1 // true, because 2 is not equal to 1
2 > 1 // true, because 2 is greater than 1
1 < 2 // true, because 1 is less than 2
1 >= 1 // true, because 1 is greater than or equal to 1
2 <= 1 // false, because 2 is not less than or equal to 1
</code></pre>
比较操作符通常用在条件语句中，比如 if 语句：
<pre><code>
let name = "world"
if name == "world" {
print("hello, world")
} else {
print("I'm sorry (name), but I don't recognize you")
}
// prints "hello, world", because name is indeed equal to "world"
</code></pre>
想了解更多关于 if 的信息，请参考控制流
三元条件操作符 Ternary Conditional Operator
三元条件操作符有三个操作数，是比较特殊的一个操作符，它是这样的形式：question ? answer1 : answer2。它根据 question 是 true 还是 false，能快捷的计算两个表达式之一的值。如果为 true，计算并返回 answer1 的值；false 计算并返回 answer2 的值
三元条件操作符是如下代码的简写：
<pre><code>
if question {
answer1
} else {
answer2
}
</code></pre>
实际使用时，参考下例：
<pre><code>
let contentHeight = 40
let hasHeader = true
let rowHeight = contentHeight + (hasHeader ? 50 : 20)
// rowHeight is equal to 90
</code></pre>
前例展开后，是如下代码
<pre><code>
let contentHeight = 40
let hasHeader = true
var rowHeight = contentHeight
if hasHeader {
rowHeight = rowHeight + 50
} else {
rowHeight = rowHeight + 20
}
// rowHeight is equal to 90
</code></pre>
如果过多使用三元条件操作符，会导致代码可读性变坏。
避免嵌套使用三元条件操作符。
Nil合并操作符 Nil Coalescing Operator
nil coalescing operator (a ?? b)，如果 Optional a 有值，就解包 a，否则如果 a 为 nil 返回 b。a 必须是 Optional 类型，b 与 a 存储的类型必须一致。
nil coalescing operator 是如下使用三元条件操作符的代码的简写：
<pre><code>
a != nil ? a! : b
</code></pre>
注：如果 a 不为 nil ，b 的值不会计算，即：短路计算（short-circuit）
举例如下：
<pre><code>
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"
</code></pre>
如果给 userDefinedColorName 赋值，则如下：
<pre><code>
userDefinedColorName = "green"
colorNameToUse = userDefinedColorName ?? defaultColorName
// userDefinedColorName is not nil, so colorNameToUse is set to "green"
</code></pre>
范围操作符 Range Operators
Swift 有两种范围操作符，用来简化一个范围内值的表示方式
封闭范围操作符 Closed Range Operator
(a...b) 定义一个从 a 到 b 的范围内的值，包括 a 和 b。a 的值一定不可以大于 b。
一般在遍历范围内所有值的时候使用，例如for-in 循环：
<pre><code>
for index in 1...5 {
print("(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
</code></pre>
半开范围操作符 Half-Open Range Operator
(a..<b) 定义一个从 a 到 b 的范围内的值，包括 a 但不包括 b。a 的值一定不可以大于 b。如果 a 等于 b，则范围为空
对于遍历从 0 开始的列表有其实用：
<pre><code>
let names = ["Anna", "Alex", "Brian", "Jack"]
let count = names.count
for i in 0..< count { //这里小于号与count要链接在一起，但因为与html冲突问题未解决，所以加了空格
print("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
</code></pre>
逻辑操作符 Logical Operators
逻辑操作符修改或组合 Boolean 逻辑值 true 和 false。Swift有三个逻辑操作符，都可以在基于C的编程语言中找到：
- 逻辑非 NOT (
!a) - 逻辑与 AND (
a && b) - 逻辑或 OR (
a || b)
Logical NOT Operator
逻辑非(!a)操作符将 Boolean 值取反，即 true 变为 false，false 变为 true
逻辑非是前缀操作符，并且要紧挨在操作数之前，之间不能有空白：
<pre><code>
let allowedEntry = false
if !allowedEntry {
print("ACCESS DENIED")
}
// prints "ACCESS DENIED"
</code></pre>
注意在给常量或变量起名时，保持代码的可读性。避免双重否定或混乱的逻辑语句
Logical AND Operator
逻辑与操作符 (a && b)，需要两个操作数都为 true 时，才返回 true，其他情况都返回 false
如果第一个操作数为 false， 第二个操作数就不会再计算了，即：短路计算
<pre><code>
let enteredDoorCode = true
let passedRetinaScan = false
if enteredDoorCode && passedRetinaScan {
print("Welcome!")
} else {
print("ACCESS DENIED")
}
// prints "ACCESS DENIED"
</code></pre>
Logical OR Operator
逻辑或操作符 (a || b)，需要两个操作数都为 false 时，才返回 false，其他情况都返回 true
如果第一个操作数为 true， 第二个操作数就不会再计算了，即：短路计算
<pre><code>
let hasDoorKey = false
let knowsOverridePassword = true
if hasDoorKey || knowsOverridePassword {
print("Welcome!")
} else {
print("ACCESS DENIED")
}
// prints "Welcome!"
</code></pre>
组合使用逻辑操作符 Combining Logical Operators
可以使用多个逻辑操作符构成一个复合表达式：
<pre><code>
if enteredDoorCode && passedRetinaScan || hasDoorKey || knowsOverridePassword {
print("Welcome!")
} else {
print("ACCESS DENIED")
}
// prints "Welcome!"
</code></pre>
该例将多个逻辑操作符（&& 和 ||）组合使用。然而，因为（&& 和 ||）都是二元操作符，所以这里实际是三个小的表达式链在一起，解读：
如果输入了正确的进门编码并且通过了视网膜扫描，或者有门钥匙，或者知道紧急超级密码，都可以访问。
注：Swift 的逻辑操作符
&&与||都是左关联，即多个逻辑操作符组成复合表达式时，最先从左边开始计算子表达式的值
显示使用括号 Explicit Parentheses
在逻辑表达式中增加括号，即使不是严格需要时，也会有助于增加代码到可读性。在上例中使用括号，如下：
<pre><code>
if (enteredDoorCode && passedRetinaScan) || hasDoorKey || knowsOverridePassword {
print("Welcome!")
} else {
print("ACCESS DENIED")
}
// prints "Welcome!"
</code></pre>
就会使逻辑语句变得关系清晰，易于阅读，并且不改变表达式的结果
网友评论