1.术语
运算符分为 一元/二元/三元 运算符
- 一元运算符对单一对象（如 -a）。一元运算符分前置运算符和后置运算符，前置运算符需紧跟在操作对象之前（如 !b），后置运算符需紧跟在操作对象之后（如 c!）。
- 二元运算符操作两个操作对象（如 2 + 3），是中置的，因为它们出现在两个操作对象之间。
- 三元运算符操作三个操作对象，和 C 语言一样，Swift 只有一个三元运算符，就是三目运算符（a ? b : c）。
- 受运算符影响的值叫操作数，在表达式 1 + 2 中，加号 + 是二元运算符，它的两个操作数是值 1 和 2。
2.赋值运算符 : =
var a = 5 //表示用 5 来初始化 a 的值
let b = 10 //表示用10 来初始化b的值
a = b // 表示用 b 的值来更新 a 的值
如果赋值的右边是一个多元组，它的元素可以马上被分解成多个常量或变量：
let (x, y) = (1, 2)
// 现在 x 等于 1，y 等于 2
与 C 语言和 Objective-C 不同，Swift 的赋值操作并不返回任何值。所以以下代码是错误的：
if x = y {
// 此句错误, 因为 x = y 并不返回任何值
}
//注意这里的错误写法有点像 if let / var 的写法,但是它们之间是不一样的 ,上面这种写法是错误的
3.算术运算符
- 加(+) 减(-) 乘(*) 除(/)
let a = 1 + 2
let b = 2 - 1
let c = 1 * 1
let d = 1 / 1
与 C 语言和 Objective-C 不同的是，Swift 默认情况下不允许在数值运算中出现溢出情况。但是你可以使用 Swift 的溢出运算符来实现溢出运算（如 a &+ b）。详情参见溢出运算符。
var a = Int8.max // 此时a == 127
var b = Int8.min // 此时 b == - 128
a = a + 1 //编译会报错,因为 a 在运算过程中出现溢出
b = b - 1 //编译会报错,因为 b 在运算过程中出现溢出
print(a)
print(b)
Swift 的 + 号运算符还可以应用于字符串之间的拼接
"aaa" + "bbb" // 拼接结果: aaabbb
4.求余运算符 %
9 % 4 // 等于 1
在求余数时,对负数 b 的符号会被忽略。这意味着 a % b 和 a % -b 的结果是相同的。
let a = 9
let b = -2
let c = 2
print(a % b)//结果是1
print(a % c)//结果是1
4.1一元负号运算符(-) 与 一元正号运算符(+)
它们与操作数之间不可以有空格
let a = -1
let b = +1
5.组合赋值运算符
var a = 1
a +=1 //a 等于2 ,这个表达式和 a + 1 的作用是一样的
var b = 2
b -= 1 //b 等于 1 ,这个表达式和 b - 1 的作用是一样的
b
注意:Swift 中没有了 a++ 或者说 ++a 的写法了,
6. 比较运算符
所有C语言的标准运算符都可以在Swift中使用
- 等于（a == b）
- 不等于（a != b）
- 大于（a > b）
- 小于（a < b）
- 大于等于（a >= b）
- 小于等于（a <= b）
注意： Swift 也提供恒等（
===）和不恒等（!==）这两个比较符来判断两个对象是否引用同一个对象实例。更多细节在类与结构。
新手在此处是无法理解 === 的
6.1 字符串之间的比较
在Swift中一般情况下是用String来代替NSString, 在比较两个字符串之间的关系是所使用的方法也不一样:
//案例代码
let name: String = "prf"
if name == "prf" {
print( " 两个字符串相等 ")
}else{
print(" 两个字符串不一样")
}
具体细节在Swift 中 NSString 与 String 的认识
6.2 元组之间的比较
let dog = (name: "dog" ,age : 2) //给元素命名的定义方法
let cat = ("cat",2)//不给元素命名的定义方法
if dog == cat {
print(" dog 等于 cat ")/
}else{
print(" dog 不等于 cat ")
}
//输出结果: dog 不等于 cat
if dog > cat {
print(" dog 大于 cat ")/
}else{
print(" dog 小于 cat ")
}
//输出结果: dog 大于 cat
//判断原理,从第一个元素开始比较,如果一致,则继续往下比较,如果不一致,
//则开始比较第一个不一致的元素之间的差别,
//"dog" 与 "cat"比较 , 先比较 第一个字母 d 与 c
- 如果元组之间的元素个数不一样,是不能拿来被比较的
- 如果两个元组在相同位置的元素的数据类型不一致,也是不能比较的
- 如果元组中包含布尔值,则不能被比较大小,因为比较运算符不能直接比较布尔值之间的大小
7.三目运算符
书写格式 问题 ? 答案 1 : 答案 2 ,它简洁地表达根据 问题成立与否作出二选一的操作,如果 问题 成立，返回 答案 1 的结果；反之返回 答案 2 的结果。
//三目运算符是以下代码的缩写形式：
question ? answer1 : answer2
if question {
answer1
} else {
answer2
}
这里有个计算表格行高的例子。如果有表头，那行高应比内容高度要高出 50 点；如果没有表头，只需高出 20 点：
let contentHeight = 40
let hasHeader = true
let rowHeight = contentHeight + (hasHeader ? 50 : 20)
// rowHeight 现在是 90
8.空合运算符
空合运算符（a ?? b）将对可选类型 a 进行空判断，如果 a 包含一个值就进行解封，否则就返回一个默认值 b。表达式 a 必须是 Optional 类型。默认值 b 的类型必须要和 a 存储值的类型保持一致。
//示例代码
let a: Int? = 1 // 注意此处a 必须定义为可选值
let b: Int = 2 //注意此处 b 的数据类型和 a 的数据类型必须一致
//常规的判断表达方法
let c = a != nil ? a : b //这是一种三目写法,并且C被系统判断为可选值
//使用空合运算符的写法
let c = a ?? b //这里c被判断为普通整型
9.区间运算符
9.1 闭区间运算符
(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
9.2 半开区间运算符
半开区间运算符（a..<b）定义一个从 a 到 b 但不包括 b 的区间。 之所以称为半开区间，是因为该区间包含第一个值而不包括最后的值。
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（最后一个元素的下标），因为它是半开区间。关于数组，请查阅数组。
9.3 单侧区间
闭区间操作符有另一个表达形式，可以表达往一侧无限延伸的区间 —— 例如，一个包含了数组从索引 2 到结尾的所有值的区间。在这些情况下，你可以省略掉区间操作符一侧的值。这种区间叫做单侧区间，因为操作符只有一侧有值。例如：
for name in names[2...] { //这句代码可以理解为:从数组的第二位元素开始遍历
print(name)
}
// Brian
// Jack
for name in names[...2] {//这句代码可以理解为:从数组的第1位元素遍历到倒数第二位
print(name)
}
// Anna
// Alex
// Brian
半开区间操作符也有单侧表达形式，附带上它的最终值。就像你使用区间去包含一个值，最终值并不会落在区间内。例如：
for name in names[..<2] { //从第一位遍历到第二位
print(name)
}
// Anna
// Ale
单侧区间不止可以在下标里使用，也可以在别的情境下使用。你不能遍历省略了初始值的单侧区间，因为遍历的开端并不明显。你可以遍历一个省略最终值的单侧区间；然而，由于这种区间无限延伸的特性，请保证你在循环里有一个结束循环的分支。你也可以查看一个单侧区间是否包含某个特定的值，就像下面展示的那样。
let range = ...5
range.contains(7) // false
range.contains(4) // true
range.contains(-1) // true
10.逻辑运算符（Logical Operators）
逻辑运算符的操作对象是逻辑布尔值。Swift 支持基于 C 语言的三个标准逻辑运算。
- 逻辑非（!a）
- 逻辑与（a && b）
- 逻辑或（a || b）
上面的三种运算符的单一使用太过简单,此处不做笔记详细使用
10.1 逻辑运算符组合计算
let enteredDoorCode = true //密码正确与否的布尔值
let passedRetinaScan = false //是否通过了虹膜扫描
let hasDoorKey = false //是否有钥匙
let knowsOverridePassword = true //是否知道重置密码的方法
if enteredDoorCode && passedRetinaScan || hasDoorKey || knowsOverridePassword {
print("Welcome!")
} else {
print("ACCESS DENIED")
}
//注意： Swift 逻辑操作符 && 和 || 是左结合的，
//这意味着拥有多元逻辑操作符的复合表达式优先计算最左边的子表达式。
//上面代码的解读:
//1.如果我们输入了正确的密码 并且 (&&) 通过了视网膜扫描，
//2.或者 (||) 我们有一把有效的钥匙，
//3.又或者 (||) 我们知道紧急情况下重置的密码，
//4.我们就能把门打开进入。
