目录
- 赋值运算符
- 算数运算符
- 余数运算符
- 一元运算
- 复合分配运算符
- 三元条件运算符
- 范围运算符
1. 近程运算符
2. 半开范围运算符
3. 单面射程 - 逻辑运算符
1.逻辑非运算符
2.逻辑与运算符
3.逻辑或运算符
4.组合逻辑运算符
术语
运算符为一元，二进制或三元：
- 一元运算符针对单个目标（例如-a）进行操作。一元前缀运算符紧接在其目标（如!b）之前，一元后缀运算符紧随其目标（如c!）之后。
- 二进制运算符在两个目标（例如）上操作，并且是中缀的，因为它们出现在两个目标之间。2 + 3
- 三元运算符针对三个目标进行操作。与C一样，Swift也只有一个三元运算符，即三元条件运算符（）。a ? b : c
赋值运算符
该赋值运算符（a=b）初始化或更新值：a = b
let b = 10
var a = 5
a = b
// a = 10
如果赋值的右侧是具有多个值的元组，则可以一次将其元素分解为多个常量或变量：
let (x, y) = (1, 2)
// x = 1, and y = 2
与C和Objective-C中的赋值运算符不同，Swift中的赋值运算符本身并不返回值。以下语句无效：
if x = y {
// This is not valid, because x = y does not return a value.
}
算数运算符
Swift支持所有数字类型的四个标准算术运算符：
- 加法（+）
- 减法（-）
- 乘法（*）
- 除法（/）
1 + 2 // equals 3
5 - 3 // equals 2
2 * 3 // equals 6
10.0 / 2.5 // equals 4.0
与C和Objective-C中的算术运算符不同，Swift算术运算符默认情况下不允许值溢出。一出算法请阅读 溢出运算符
String串联还支持加法运算符:
"hello, " + "world" // equals "hello, world"
余数运算符
注意
余数运算符（%）在其他语言中也称为模运算符。但是，它在Swift中的负数行为意味着严格来说，这是余数而不是取模运算。
比如：9 % 4，要进行计算，您首先要计算出其中可以容纳多少个：
可以4在内9放两个，其余为1（显示为橙色）。
9 % 4 // equals 1
9=（4x 2）+1 //可以看出9里面可以容纳2个4，余下1
-9 % 4 // equals -1
-9=（4x -2）+-1
一元运算
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
复合分配运算符
像C一样，Swift提供复合赋值运算符，将赋值（=）与另一个操作结合在一起。一个示例是加法赋值运算符（+=）：
var a = 1
a += 2
// a is now equal to 3
注意
复合赋值运算符不返回值。例如，您不能编写。let b = a += 2
有关Swift标准库提供的运算符的信息，请参见运算符声明。
Swift支持以下比较运算符：
- 等于（）a == b
- 不等于（）a != b
- 大于（）a > b
- 小于（）a < b
- 大于或等于（）a >= b
- 小于或等于（）a <= b
注意
Swift还提供了两个标识运算符（===和!==），用于测试两个对象引用是否都引用同一对象实例。有关更多信息，请参见身份运算符。
1 == 1 // true because 1 is equal to 1
2 != 1 // true because 2 is not equal to 1
2 > 1 // true because 2 is greater than 1
1 < 2 // true because 1 is less than 2
1 >= 1 // true because 1 is greater than or equal to 1
2 <= 1 // false because 2 is not less than or equal to 1
如果两个元组具有相同的类型和相同数量的值，则可以比较它们。元组从左到右进行比较，一次比较一个值，直到比较发现两个不相等的值。将这两个值进行比较，比较的结果确定元组比较的整体结果。如果所有元素相等，则元组本身相等。例如：
(1, "zebra") < (2, "apple") // true because 1 is less than 2; "zebra" and "apple" are not compared
(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"
在上面的示例中，您可以在第一行看到从左到右的比较行为。因为1小于2，被认为小于，而不管元组中的任何其他值。不小于等于没关系，因为比较已经由元组的第一个元素确定。但是，当元组的第一个元素相同时，将比较它们的第二个元素-这就是第二行和第三行的情况。(1, "zebra")(2, "apple")"zebra""apple"
只有将运算符应用于各个元组中的每个值，才可以将其与给定的运算符进行比较。例如，如下面的代码所示，您可以比较两个类型的元组，因为可以使用运算符比较和值。相反，不能将两个类型的元组与运算符进行比较，因为不能将运算符应用于值。
(String, Int)StringInt<(String, Bool)<<Bool
("blue", -1) < ("purple", 1) // OK, evaluates to true
("blue", false) < ("purple", true) // Error because < can't compare Boolean values
注意
Swift标准库包括用于少于七个元素的元组的元组比较运算符。要比较具有七个或更多元素的元组，必须自己实现比较运算符。
三元条件运算符
所述三元条件算子是由三个部分组成，这需要形式的特殊操作。这是根据是对还是错来评估两个表达式之一的捷径。question ? answer1 : answer2 如果question为true就返回answer1，如果question为false就返回answer2。
let question:Bool = false
if question {
print("1")
} else {
print("2")
}
let answer = question ? "1" : "2"
answer = “2”
注意
question应该是一个值为Bool值或者是值为Bool的表达式
nil-coalescing运算符
如果nil-coalescing运算符（a ?? b）包含值，则解开可选的a；如果a为nil，则返回默认值b。 表达式a始终是可选类型。 表达式b必须与a内存储的类型匹配。
nil-coalescing运算符是以下代码的简写：
a != nil ? a! : b
可以把nil-coalescing运算符当作简化的三元条件运算符。
let defaultColorName = "red"
var userDefinedColorName: String? // defaults to nil
var colorNameToUse = userDefinedColorName ?? defaultColorName
// userDefinedColorName is nil, so colorNameToUse is set to the default of "red"
范围运算符
- 近程运算符
- 半开范围运算符
- 单面射程
1. 近程运算符
封闭范围运算符（a ... b）定义了一个从a到b的范围，并包括值a和b。 a的值不能大于b。
在要使用所有值的范围内进行迭代时，例如使用for-in循环，封闭范围运算符非常有用。
for index in 1...5 {
print("\(index) times 5 is \(index * 5)")
}
// 1 times 5 is 5
// 2 times 5 is 10
// 3 times 5 is 15
// 4 times 5 is 20
// 5 times 5 is 25
2. 半开范围运算符
所述半开区间运算符（a..<b）限定的范围内，从运行a到b，但不包括b。据说它是半开的，因为它包含其第一个值，但不包含其最终值。与封闭范围运算符一样，的值a不得大于b。如果的值a等于b，则结果范围将为空。
let names = ["Anna", "Alex", "Brian", "Jack"]
let count = names.count
for i in 0..<count {
print("Person \(i + 1) is called \(names[i])")
}
// Person 1 is called Anna
// Person 2 is called Alex
// Person 3 is called Brian
// Person 4 is called Jack
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
//...5代表小于等于5的区间
//range.contains(7) 7不包含在区间中，所以false
//range.contains(4) //4包含在区间中，所以 true
逻辑运算符
逻辑运算符修改或组合布尔逻辑值true和false。Swift支持基于C语言的三种标准逻辑运算符：
- 逻辑非（!a）
- 逻辑与（）a && b
- 逻辑或（）a || b
1.逻辑非运算符
逻辑非运算符（!a）反转一个布尔值，使得true成为false，和false变true。
let allowedEntry = false
if !allowedEntry {
print("ACCESS DENIED")
}
// Prints "ACCESS DENIED"
2.逻辑与运算符
逻辑AND运算符（）创建逻辑表达式，其中这两个值必须为整体表达也有，必须两个都为true条件才算成立。a && b true true
如果任一个值为false，则总表达式也将为false。实际上，如果第一个值为false，则第二个值甚至都不会被求值，因为它不可能使整个表达式等于true。这被称为短路评估。
let enteredDoorCode = true
let passedRetinaScan = false
if enteredDoorCode && passedRetinaScan {
print("Welcome!")
} else {
print("ACCESS DENIED")
}
// Prints "ACCESS DENIED"
3.逻辑或运算符
逻辑OR运算符（）是来自两个相邻管字符制成中缀运算符。您可以使用它来创建逻辑表达式，其中对于整个表达式而言，两个值中只有一个必须true就成立。a || b true true
let hasDoorKey = false
let knowsOverridePassword = true
if hasDoorKey || knowsOverridePassword {
print("Welcome!")
} else {
print("ACCESS DENIED")
}
// Prints "Welcome!"
4.组合逻辑运算符
if (enteredDoorCode && passedRetinaScan) || hasDoorKey || knowsOverridePassword {
print("Welcome!")
} else {
print("ACCESS DENIED")
}
// Prints "Welcome!"
// 括号可以简化去掉
if enteredDoorCode && passedRetinaScan || hasDoorKey || knowsOverridePassword {
print("Welcome!")
} else {
print("ACCESS DENIED")
}
// Prints "Welcome!"
注意
Swift逻辑运算符&&和||是左关联的，这意味着具有多个逻辑运算符的复合表达式首先评估最左边的子表达式。
