运算符分为一元、二元和三元运算符
一、赋值运算符
- 赋值运算符:
= - 例如: (
a = b), 表示用b的值来初始化或更新a的值
let b = 10
var a = 15
a = b
// a 现在等于15
- 如果赋值的右边是一个多元组, 他的元素可以马上分解成多个常量或变量:
let (x, y) = (1, 2)
- 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
- Swift默认情况下不允许在数值运算中出现溢出情况
var number: Int8 = 0;
number = 128; // 报错: Integer literal '128' overflows when stored into 'Int8'
- 加法运算符也可用户字符串拼接
"hello" + " " + "world" // 等于 "hello world"
三、求余运算符
- 求余运算符（
a % b）是计算b的多少倍刚刚好可以容入a，返回多出来的那部分（余数）。
9 % 4 // 等于 1
- 在对负数
b求余时,b的符号会被忽略, 这意味着a % b和a % -b的结果是相同的
let a = 9 % 4; // a 等于 1
let b = 9 % -4; // b 等于 1
四、一元负号运算符
- 竖直的正负可以使用前缀
-来切换
let a = 3
let b = -a // b 等于 -3
let c = -b // c 等于 3
一元负号符(
-)写在操作数之前, 中间没有空格
五、一元正号运算符
- 一元正号符(
+)不做任何改变的返回操作数的值
let a = -6
let b = +a // b 等于 -6
六、组合赋值运算符
- 组合赋值运算符: 将基本四则运算符和赋值运算符组合在一起使用
- 加等(
+=)、减等(-=)、乘等(*=)、除等(/=)、余等(%=)
var a = 1
a += 2 <==> a = a + 2, a 等于 3
a -= 1 <==> a = a - 1, a 等于 2
a *= 3 <==> a = a * 3, a 等于 6
a /= 2 <==> a = a / 2, a 等于 3
a %= 2 <==> a = a % 2, a 等于 1
注意: 复合赋值运算符没有返回值,
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
比较运算多用于条件语句
- 如果两个元组的元素类型相同, 且长度相同的话, 元组就可以被比较。
- 比较元组大小会按照从左到右、逐值比较的方式，直到发现有两个值不等时停止。
(1, "zebra") < (2, "apple") // true，因为 1 小于 2
(3, "apple") < (3, "bird") // true，因为 3 等于 3，但是 apple 小于 bird
(4, "dog") == (4, "dog") // true，因为 4 等于 4，dog 等于 dog
- 有布尔类型的元组不能被比较。
("blue", -1) < ("purple", 1) // 正常，比较的结果为 true
("blue", false) < ("purple", true) // 错误，因为 < 不能比较布尔类型
注意
Swift 标准库只能比较七个以内元素的元组比较函数。如果你的元组元素超过七个时，你需要自己实现比较运算符。
八、三元运算符
- 三元运算符:
问题 ? 答案1 : 答案2, 当问题成立, 返回答案1, 否则返回答案2 - 三元运算符是以下代码的缩写形式
if question {
answer1
} else {
answer2
}
九、空合运算符
空合运算符:
a ?? b对可选类型
a进行空判断, 如果a包含一个值就进行解封, 否则就返回一个默认值b。表达式a必须是 Optional 类型, 默认值b的类型必须要和a存储值的类型保持一致空合运算符是对以下代码的简短表达方法:
a != nil ? a! : b
注意
如果a为非空值(non-nil), 那么值b将不会被计算。这也就是所谓的短路求值
十、区间运算符
Swift提供了几种方便表达一个区间的值的区间运算符
1、闭区间运算符
- 闭区间运算符:
a...b定义一个包含从a到b(包括a和b)的所有值的区间。a的值不能超过b - 闭区间运算符在迭代一个区间的所有值时是非常有用的
for index in 1...5 {
print("\(index) * 5 = \(index * 5)")
}
2、半开区间运算符
半开区间运算符:
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])")
}
3、单侧区间
- 闭区间操作符有另一个表达形式, 可以表达往一侧无限延伸的区间
for name in names[2...] { // 取值 2..<names.count
print(name)
}
// Brian
// Jack
for name in names[...2] { // 取值 0...2
print(name)
}
// Anna
// Alex
// Brian
单侧区间不止可以在下标里使用，也可以在别的情境下使用。你不能遍历省略了初始值的单侧区间，因为遍历的开端并不明显。你可以遍历一个省略最终值的单侧区间；然而，由于这种区间无限延伸的特性，请保证你在循环里有一个结束循环的分支。
你也可以查看一个单侧区间是否包含某个特定的值，就像下面展示的那样。
let range = ...5
range.contains(7) // false
range.contains(4) // true
range.contains(-1) // true
十一、逻辑运算符
- 逻辑运算符的操作对象是逻辑布尔值, Swift支持基于C语言的三个标准逻辑运算符
- 逻辑非(
!a)、逻辑与(a && b)、逻辑或(a || b)
1、逻辑非运算符
- 逻辑非运算符(
!a)对一个布尔值取反, 使true变false,false变true - 他是一个前置运算符, 需紧跟在操作数之前, 且不加空格, 读作
非a, 例子如下
let allowedEntry = false
if !allowedEntry {
print("ACCESS DENIED")
}
// 输出 "ACCESS DENIED"
2、逻辑与运算符
- 逻辑与运算符（
a && b）表达了只有a和b的值都为true时，整个表达式的值才会是true。 - 只要任意一个值为
false，整个表达式的值就为false。
let enteredDoorCode = true
let passedRetinaScan = false
if enteredDoorCode && passedRetinaScan {
print("Welcome!")
} else {
print("ACCESS DENIED")
}
// 输出 "ACCESS DENIED"
事实上，如果第一个值为
false，那么是不去计算第二个值的，因为它已经不可能影响整个表达式的结果了。这被称做短路计算
3、逻辑或运算符
- 逻辑或运算符（
a || b）是一个由两个连续的|组成的中置运算符。它表示了两个逻辑表达式的其中一个为true，整个表达式就为true。
同逻辑与运算符类似，逻辑或也是「短路计算」的，当左端的表达式为
true时，将不计算右边的表达式了，因为它不可能改变整个表达式的值了。
let hasDoorKey = false
let knowsOverridePassword = true
if hasDoorKey || knowsOverridePassword {
print("Welcome!")
} else {
print("ACCESS DENIED")
}
// 输出 "Welcome!"
4、逻辑运算符组合计算
if enteredDoorCode && passedRetinaScan || hasDoorKey || knowsOverridePassword {
print("Welcome!")
} else {
print("ACCESS DENIED")
}
// 输出 "Welcome!"
如果我们输入了正确的密码并通过了视网膜扫描，或者我们有一把有效的钥匙，又或者我们知道紧急情况下重置的密码，我们就能把门打开进入。
前两种情况，我们都不满足，所以前两个简单逻辑的结果是
false，但是我们是知道紧急情况下重置的密码的，所以整个复杂表达式的值还是true。
注意
Swift 逻辑操作符 && 和 || 是左结合的，这意味着拥有多元逻辑操作符的复合表达式优先计算最左边的子表达式。
5、使用括号来明确优先级
- 为了一个复杂表达式更容易读懂，在合适的地方使用括号来明确优先级是很有效的，虽然它并非必要的。在上个关于门的权限的例子中，我们给第一个部分加个括号，使它看起来逻辑更明确:
if (enteredDoorCode && passedRetinaScan) || hasDoorKey || knowsOverridePassword {
print("Welcome!")
} else {
print("ACCESS DENIED")
}
// 输出 "Welcome!"
- 这括号使得前两个值被看成整个逻辑表达中独立的一个部分。虽然有括号和没括号的输出结果是一样的，但对于读代码的人来说有括号的代码更清晰。可读性比简洁性更重要，请在可以让你代码变清晰的地方加个括号吧！
