Swift学习笔记 (四) 基本运算符(上)

运算符是检查、改变、合并值的特殊符号或短语。例如，加号( + )将两个数相加(如 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 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 中:

你可以在 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 这类代码是错误的。这不同于上面提到的自增和自减运算符。

 

比较运算符

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

等于( a == b )

不等于( a!=b )

大于( a > b )

小于( a < b )

大于等于( a>=b )

小于等于( a<=b )

注意

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

IdentityOperators 部分。

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

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, "b")       // true，因为 3 等于 3，但是 apple 小于 b，字符串比较应该是字母ASCII 逐个比较 a < b

(4, "dog") == (4, "dog")       // true，因为 4 等于 4，dog 等于 dog

 

在上面的例子中，你可以看到，在第一⾏中从左到右的比较⾏为。因为 1 小于 2 ，所以 (1, "zebra") 小于 (2, "apple") ，不管元组

剩下的值如何。所以 "zebra" 大于 "apple" 对结果没有任何影响，因为元组的比较结果已经被第一个元素决定了。不过，当元组

的第一个元素相同时候，第二个元素将会用作比较。第二⾏和第三行代码就发生了这样的比较。

当元组中的元素都可以被比较时，你也可以使用这些运算符来比较它们的⼤小。例如，像下⾯面展示的代码，你可以比较两个类

型为(String, Int) 的元组，因为 Int 和 String 类型的值可以比较。相反， Bool 不能被比较，也意味着存有布尔类型的元组不能被

比较。

("blue", -1) < ("purple", 1)                        // 正常，⽐较的结果为 true

("blue", false) < ("purple", true)              // 错误，因为 < 不能比较布尔类型

注意

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

 

三元运算符

三元运算符的特殊在于它是有三个操作数的运算符，它的形式是 问题 ? 答案 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 语句中改变。

三元运算为二选一场景提供了一个⾮常便捷的表达形式。不过需要注意的是，滥⽤三元运算符会降低代码可读性。所以我们应避

免在一个复合语句中使用多个三元运算符。