Swift学习笔记 (五) 基本运算符(下)

空合运算符

空合运算符( 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
// userDefinedColorName ⾮空，因此 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

 

半开区间运算符

半开区间运算符( 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(最后一个元素的下标)，因为它是半开区间。

 

单侧区间

闭区间操作符有另一个表达形式，可以表达往一侧无限延伸的区间 —— 例如，一个包含了数组从索引 2 到结尾的所有值的区

间。在这些情况下，你可以省略掉区间操作符一侧的值。这种区间叫做单侧区间，因为操作符只有一侧有值。例如:

for name in names[2...] {

            print(name)

}

// Brian

// Jack

for name in names[...2] {

           print(name)

}

// Anna

// Alex

// Brian

半开区间操作符也有单侧表达形式，附带上它的最终值。就像你使用区间去包含一个值，最终值并不会落在区间内。例如:

for name in names[..<2] {

            print(name)

}

// Anna

// Alex 

单侧区间不止可以在下标⾥使用，也可以在别的情景下使用。你不能遍历省略了初始值的单侧区间，因为遍历的开端并不明显。

你可以遍历一个省略最终值的单侧区间;然而，由于这种区间无限延伸的特性，请保证你在循环⾥有一个结束循环的分支。你也可

以查看一个单侧区间是否包含某个特定的值，就像下面展示的那样。

let range = ...5

range.contains(7) // false

range.contains(4) // true

range.contains(-1) // true

 

逻辑运算符

逻辑运算符的操作对象是逻辑布尔值。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 的时候才允许进入 if:

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

这括号使得前两个值被看成整个逻辑表达中独⽴的一个部分。虽然有括号和没括号的输出结果是一样的，但对于读代码的人来说

有括号的代码更清晰。可读性比简洁性更重要，请在可以让你代码变清晰的地方加个括号吧!