swift官方推荐翻译文档之基本运算符

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

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

区别于 C 语言，在 Swift 中你能够对浮点数进行取余运算（%），Swift 还提供了 C 语言没有的表达两数之间的值的区间运算符（a..<b和a...b），这方便咱们表达一个区间内的数值。

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

术语

运算符有一元、二元和三元运算符。

• 一元运算符对单一操做对象操做（如-a）。一元运算符分前置运算符和后置运算符，前置运算符需紧跟在操做对象以前（如!b），后置运算符需紧跟在操做对象以后（如i++）。

• 二元运算符操做两个操做对象（如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 并不返回任何值
}

这个特性使你没法把（==）错写成（=），因为if x = y是错误代码，Swift帮你避免此类错误的的发生。

算术运算符

Swift 中全部数值类型都支持了基本的四则算术运算：

• 加法（+）

• 减法（-）

• 乘法（*）

• 除法（/）

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

与 C 语言和 Objective-C 不一样的是，Swift 默认状况下不容许在数值运算中出现溢出状况。可是你可使用 Swift 的溢出运算符来实现溢出运算（如a &+ b）。详情参见溢出运算符。

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

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

求余运算符

求余运算（a % b）是计算b的多少倍刚恰好能够容入a，返回多出来的那部分（余数）。

注意：
求余运算（%）在其余语言也叫取模运算。然而严格说来，咱们看该运算符对负数的操做结果，"求余"比"取模"更合适些。

咱们来谈谈取余是怎么回事，计算9 % 4，你先计算出4的多少倍会恰好能够容入9中：

2倍，很是好，那余数是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的结果是相同的。

浮点数求余计算

不一样于 C 语言和 Objective-C，Swift 中是能够对浮点数进行求余的。

8 % 2.5   // 等于 0.5

这个例子中，8除于2.5等于3余0.5，因此结果是一个Double值0.5。

自增和自减运算

和 C 语言同样，Swift 也提供了对变量自己加1或减1的自增（++）和自减（--）的缩略算符。其操做对象能够是整形和浮点型。

var i = 0
++i      // 如今 i = 1

每调用一次++i，i的值就会加1。实际上，++i是i = i + 1的简写，而--i是i = i - 1的简写。

++和--既能够用做前置运算又能够用做后置运算。++i，i++，--i和i--都是有效的写法。

咱们须要注意的是这些运算符便可修改了i的值也能够返回i的值。若是你只想修改i的值，那你就能够忽略这个返回值。但若是你想使用返回值，你就须要留意前置和后置操做的返回值是不一样的，她们遵循如下原则：

• 当++前置的时候，先自増再返回。

• 当++后置的时候，先返回再自增。

例如：

var a = 0
let b = ++a // a 和 b 如今都是 1
let c = a++ // a 如今 2, 但 c 是 a 自增前的值 1

上述例子，let b = ++a先把a加1了再返回a的值。因此a和b都是新值1。

而let c = a++，是先返回了a的值，而后a才加1。因此c获得了a的旧值1，而a加1后变成2。

除非你须要使用i++的特性，否则推荐你使用++i和--i，由于先修改后返回这样的行为更符合咱们的逻辑。

一元负号运算符

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

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

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

一元正号运算符

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

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

虽然一元+什么都不会改变，但当你在使用一元负号来表达负数时，你可使用一元正号来表达正数，如此你的代码会具备对称美。

组合赋值运算符（Compound Assignment Operators）

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

var a = 1
a += 2 // a 如今是 3

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

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

比较运算符

全部标准 C 语言中的比较运算均可以在 Swift 中使用：

• 等于（a == b）

• 不等于（a != b）

• 大于（a > b）

• 小于（a < b）

• 大于等于（a >= b）

• 小于等于（a <= b）

注意： Swift 也提供恒等===和不恒等!==这两个比较符来判断两个对象是否引用同一个对象实例。更多细节在类与结构。

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

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语句，请看控制流。

三目运算符(Ternary Conditional Operator)

三目运算符的特殊在于它是有三个操做数的运算符，它的原型是 问题 ? 答案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
var rowHeight = contentHeight
if hasHeader {
    rowHeight = rowHeight + 50
} else {
    rowHeight = rowHeight + 20
}
// rowHeight 如今是 90

第一段代码例子使用了三目运算，因此一行代码就能让咱们获得正确答案。这比第二段代码简洁得多，无需将rowHeight定义成变量，由于它的值无需在if语句中改变。

三目运算提供有效率且便捷的方式来表达二选一的选择。须要注意的事，过分使用三目运算符会使简洁的代码变的难懂。咱们应避免在一个组合语句中使用多个三目运算符。

空合运算符(Nil Coalescing Operator)

空合运算符(a ?? b)将对可选类型a进行空判断，若是a包含一个值就进行解封，不然就返回一个默认值b.这个运算符有两个条件:

• 表达式a必须是Optional类型

• 默认值b的类型必需要和a存储值的类型保持一致

空合运算符是对如下代码的简短表达方法

a != nil ? a! : b

上述代码使用了三目运算符。当可选类型a的值不为空时，进行强制解封(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
// userDefinedColorName 非空，所以 colorNameToUse 的值为 "green"

区间运算符

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

闭区间运算符

闭区间运算符（a...b）定义一个包含从a到b(包括a和b)的全部值的区间，b必须大于等于a。 ‌ 闭区间运算符在迭代一个区间的全部值时是很是有用的，如在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..<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])")
}
// 第 1 我的叫 Anna
// 第 2 我的叫 Alex
// 第 3 我的叫 Brian
// 第 4 我的叫 Jack

数组有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")
}
// 输出 "ACCESS DENIED"

if !allowedEntry语句能够读做“若是非 allowedEntry。”，接下一行代码只有在“非 allowedEntry”为true，即allowEntry为false时被执行。

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

逻辑与

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

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

如下例子，只有两个Bool值都为true的时候才容许进入：

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

逻辑或

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

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

如下示例代码中，第一个布尔值（hasDoorKey）为false，但第二个值（knowsOverridePassword）为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!"

这个例子使用了含多个&&和||的复合逻辑。但不管怎样，&&和||始终只能操做两个值。因此这实际是三个简单逻辑连续操做的结果。咱们来解读一下：

若是咱们输入了正确的密码并经过了视网膜扫描，或者咱们有一把有效的钥匙，又或者咱们知道紧急状况下重置的密码，咱们就能把门打开进入。

前两种状况，咱们都不知足，因此前两个简单逻辑的结果是false，可是咱们是知道紧急状况下重置的密码的，因此整个复杂表达式的值仍是true。

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

使用括号来明确优先级

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

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

这括号使得前两个值被当作整个逻辑表达中独立的一个部分。虽然有括号和没括号的输出结果是同样的，但对于读代码的人来讲有括号的代码更清晰。可读性比简洁性更重要，请在可让你代码变清晰的地方加个括号吧！