《Swift学习笔记》05 - 基本运算符简介

介绍：Swift 语言由苹果公司在 2014 年推出，用来撰写 Mac OS 和 iOS 应用程序，并且Swift还是开源的，开源地址:https://github.com/apple/swift，同时附上官方博客地址：https://swift.org
目前Swift已经发展到了第五版本。显然苹果大有推翻 OC “江山”的意思.
今天就来初探一下Swift，看看究竟为何swift有这么大的能力。
参考内容：
Swift中文
YungFan老师

swift

1. 基本运算符介绍

• Swift 在支持 C 中的大多数标准运算符的同时也增加了一些排除常见代码错误的能力。赋值符号（ = ）不会返回值，以防它被误用于等于符号（ == ）的意图上。算数符号（ + , - , * , / , % 以及其他）可以检测并阻止值溢出，以避免你在操作比储存类型允许的范围更大或者更小的数字时得到各种奇奇怪怪的结果。
• Swift 提供了两种 C 中没有的区间运算符（ a..

2. 专门用语

运算符包括一元、二元、三元：

• 一元运算符对一个目标进行操作（比如 -a ）。一元前缀运算符在目标之前直接添加（比如 !b ），同时一元后缀运算符直接在目标末尾添加（比如 c! ）。
• 二元运算符对两个目标进行操作（比如 2 + 3 ）同时因为它们出现在两个目标之间，所以是中缀。
• 三元运算符操作三个目标。如同 C，Swift语言也仅有一个三元运算符，三元条件运算符（ a ? b : c ）。

受到运算符影响的值叫做操作数。在表达式 1 + 2 中， + 符号是一个二元运算符，其中的两个值 1 和 2 就是操作数。

3. 赋值运算

• 赋值运算符（ a = b ）可以初始化或者更新 a 为 b 的值：

let a = 10
let b = 20
let c = a + b

• 如果赋值符号右侧是拥有多个值的元组，它的元素将会一次性地拆分成常量或者变量：

let (d , e) = (10, 20)
print(d, e)
//print 10 20

与 Objective-C 和 C 不同，Swift 的赋值符号自身不会返回值。下面的语句是不合法的：

if x = y {
    // 这是不合法的, 因为 x = y 并不会返回任何值。
}

这个特性避免了赋值符号 (=) 被意外地用于等于符号 (==) 的实际意图上。Swift 通过让 if x = y 非法来帮助你避免这类的错误在你的代码中出现。

4. 算数运算符

和其他编程语言并无不同。Swift 对所有的数字类型支持四种标准算术运算符：

• 加 ( + )

• 减 ( - )

• 乘 ( * )

• 除 ( / )

• 求余 (%)

• 不同于OC，Swift支持 String 的拼接

"hello " + "Swift" 
//print "hello Swift"

• 一元减号/加法运算符
  数字值的正负号可以用前缀 – 来切换，我们称之为 一元减号运算符：
  一元减号运算符（ - ）直接在要进行操作的值前边放置，不加任何空格。

let three = 3
let minusThree = -three // minusThree equals -3
let plusThree = -minusThree // plusThree equals 3, or "minus minus three"

一元加号运算符 （ + ）直接返回它操作的值，不会对其进行任何的修改：

let minusSix = -6
let alsoMinusSix = +minusSix // alsoMinusSix equals -6

尽管一元加号运算符实际上什么也不做，你还是可以对正数使用它来让你的代码对一元减号运算符来说显得更加对称。

5. 组合赋值符号

如同 C ，Swift 提供了由赋值符号（ = ）和其他符号组成的 组合赋值符号 。一个加赋值符号的栗子 （ += ）：

var a = 1
a += 2
// a is now equal to 3

表达式 a += 2 其实就是 a = a + 2 的简写。效率上来讲，加号和赋值符号组合成的一个运算符能够同时进行这两个操作。
注意：
组合运算符不会返回任何值。举例来说，你不能写成这样 let b = a += 2 。这个与前边提到的增量和减量符号的行为不同。

6. 比较运算符

Swift 支持所有 C 的标准比较运算符：
相等 ( a == b )
不相等 ( a != b )
大于 ( a > b )
小于 ( a < b )
大于等于 ( a >= b )
小于等于 ( a <= b )

Swift 同时也提供两个等价运算符（ === 和 !== ），你可以使用它们来判断两个对象的引用是否相同。

• 你同样可以比较拥有同样数量值的元组，只要元组中的每个值都是可比较的。比如说，Int 和 String 都可以用来比较大小，也就是说 (Int,String) 类型的元组就可以比较。一般来说， 比较的元组每个对应的类型要是相同的，同时Bool 不能比较，这意味着包含布尔值的元组不能用来比较大小。
  元组以从左到右的顺序比较大小，一次一个值，直到找到两个不相等的值为止。如果所有的值都是相等的，那么就认为元组本身是相等的。比如说：

(1, "zebra") < (2, "apple")   // true because 1 is less than 2
(3, "apple") < (3, "bird")    // true because 3 is equal to 3, and "apple" is less than "bird"
(4, "dog") == (4, "dog")      // true because 4 is equal to 4, and "dog" is equal to "dog"

Swift 标准库包含的元组比较运算符仅支持小于七个元素的元组。要比较拥有七个或者更多元素的元组，你必须自己实现比较运算符。

7. 三元条件运算符

三元条件运算符是一种有三部分的特殊运算，它看起来是这样的： question ? answer1 : answer2 。这是一种基于 question 是真还是假来选择两个表达式之一的便捷写法。如果 question 是真，则会判断为 answer1 并且返回它的值；否则，它判断为 answer2 并且返回它的值。

let contentHeight = 40
let hasHeader = true
let rowHeight = contentHeight + (hasHeader ? 50 : 20)
// rowHeight is equal to 90

8. 合并空值运算符

合并空值运算符 （ a ?? b ）如果可选项 a 有值则展开，如果没有值，是 nil ，则返回默认值 b 。表达式 a 必须是一个可选类型。表达式 b 必须与 a 的储存类型相同。

合并空值运算符是下边代码的缩写：

a != nil ? a! : b

如果 a 的值是非空的， b 的值将不会被考虑。这就是所谓的 短路计算 。

let defaultColorName = "red"
var userDefinedColorName: String? // defaults to nil
var colorNameToUse = userDefinedColorName ?? defaultColorName
// 返回了 defaultColorName  的值， red 

如果你给 userDefinedColorName 指定一个非空的值然后让合并空值运算符在检查一次，那么 userDefinedColorName 中封装的值将会替换掉默认值：

userDefinedColorName = "green"
colorNameToUse = userDefinedColorName ?? defaultColorName

// 返回了 userDefinedColorName  的值， green 

9. 区间运算符

Swift 包含了两个 区间运算符 ，他们是表示一个范围的值的便捷方式。

9.1 闭区间运算符

• 闭区间运算符（ a...b ）定义了从 a 到 b 的一组范围，并且包含 a 和 b 。 a 的值不能大于 b 。

for index in 1...5 {
    print(index);
}
// print : 1
// print : 2
// print : 3
// print : 4
// print : 5

9.2 半开区间运算符

• 半开区间运算符（ a..定义了从 a 到 b 但不包括 b 的区间，即半开，因为它只包含起始值但并不包含结束值。（十奶注：其实就是左闭右开区间。）如同闭区间运算符， a 的值也不能大于 b ，如果 a 与 b 的值相等，那返回的区间将会是空的

let names = ["Anna", "Alex", "Brian", "Jack"]
let count = names.count
for i in 0..

注意数组包含四个元素，但是 0..

9.3 单侧区间
闭区间有另外一种形式来让区间朝一个方向尽可能的远——比如说，一个包含数组所有元素的区间，从索引 2 到数组的结束。在这种情况下，你可以省略区间运算符一侧的值。因为运算符只有一侧有值，所以这种区间叫做单侧区间。
我理解为：
[值...]：取出从某一位开始到最后一位的所有元素
[...值]：取出从某一位开始到最后一位的所有元素

for name in names[1...] {
    print(name)
}

for name in names[...3] {
    print(name)
}

for name in names[1...3] {
    print(name)
}

for name in names[1..<3] {
    print(name)
}

单侧区间可以在其他上下文中使用，不仅仅是下标。你不能遍历省略了第一个值的单侧区间，因为遍历根本不知道该从哪里开始。你可以遍历省略了最终值的单侧区间；总之，由于区间无限连续，你要确保给循环添加一个显式的条件。你同样可以检测单侧区间是否包含特定的值，就如下面的代码所述。

let range = ...5
range.contains(7)   // false
range.contains(4)   // true
range.contains(-1)  // true

10. 逻辑运算符

常见的逻辑运算符分为：

• 与 （a && b）：两者都为真才成立（true）， 否则为（ false ）

• 或（a || b）：两者中有一个为为真 就成立（true），两者同时为假 才为 （ false ）

• 非 （ !a ） ： 转换 bool 值 ，把 true 变成 false ， 把 false 变成 true 。

同时 它们之前可以进行混合的逻辑运算

let oneTrue = true
let twoFalse = false
let threeTrue = true

if !oneTrue {
    print("oneTrue 为 假")
}else{
    print("oneTrue 为 真")
}
// oneTrue 为 真

if !twoFalse {
    print("twoFalse 为 假")
}else{
    print("twoFalse 为 真")
}
// twoFalse 为 假

if oneTrue && twoFalse {
    print("oneTrue 和 twoFalse 都为真!")
}else{
    print("oneTrue 和 twoFalse 中有一个为假!")
}
// oneTrue 和 twoFalse 中有一个为假!

if oneTrue || twoFalse {
    print("oneTrue 和 twoFalse 中有一个为假!")
}else{
    print("oneTrue 和 twoFalse 都为假!")
}
// oneTrue 和 twoFalse 中有一个为假!

混合逻辑运算
Swift 语言中逻辑运算符 && 和 || 是左相关的，这意味着多个逻辑运算符组合的表达式会首先计算最左边的子表达式。

if oneTrue || twoFalse || threeTrue && fourTrue{
    print("为真")
}else{
    print("为假")
}

显示括号
很多时候虽然不被要求，但使用括号还是很有用的，这能让复杂的表达式更容易阅读。
先会优先执行括号里面的

if (oneTrue || threeTrue) && twoFalse {
    print("为真")
}else{
    print("为假")
}

// 为假

好了：到这里基本运算符就学习完了

可选类型的介绍就到这里了。有什么不足的地方欢迎补充。文章大多数内容来自：

Swift中文
YungFan老师
再次感谢！

求职广告：本人实习生，现在急需一份工作，杭州南京合肥的都可以。对我感兴趣的可以私聊我 0.0。谢谢～～～