赋值运算符
赋值运算符 = 用来给变量或常量赋值，其语法如下：
1
2
3
let value = 10
var result = 0
result = value
在上面的例子中，我们先定义了一个常量 value，并初始化为 10，然后定义了一个变量 result 并初始化为 0，最后将 value 的值赋给 result。
算术运算符
Swift 中的算术运算符包括加减乘除和取余操作等。其中加法运算符 + 既可以用于两个数之间的运算，也可以用于字符串之间的拼接。例如：
1
2
3
4
5
6
7
let a = 10
let b = 20
let c = a + b // c = 30
let str1 = "Hello"
let str2 = "Swift"
let str3 = str1 + " " + str2 // str3 = "Hello Swift"
减法运算符 - 用于两个数之间的减法，乘法运算符 * 用于两个数之间的乘法，除法运算符 / 用于两个数之间的除法。例如：
1
2
3
4
5
6
7
8
9
10
11
let a = 10
let b = 20
let c = a - b // c = -10
let x = 3
let y = 4
let z = x * y // z = 12
let m = 20
let n = 7
let p = m / n // p = 2
取余操作使用 % 运算符，表示两个数相除后的余数。例如：
1
2
3
let a = 17
let b = 5
let c = a % b // c = 2
复合赋值运算符
Swift 提供了一系列复合赋值运算符，用于进行多种运算操作。例如，+= 运算符可以将右侧的值加到左侧的变量上，并将结果再次赋给左侧的变量；-= 运算符可以将右侧的值从左侧的变量中减去，并将结果再次赋给左侧的变量。其他的复合赋值运算符还包括 *=, /=, %= 等。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
var a = 10
a += 5 // a = 15
var b = 20
b -= 10 // b = 10
var c = 3
c *= 2 // c = 6
var d = 10
d /= 3 // d = 3
var e = 17
e %= 5 // e = 2
比较运算符
Swift 中的比较运算符用于比较两个值大小关系，返回一个布尔值（true/false）。比较运算符包括：小于 <，大于 >，小于等于 <=，大于等于 >=，等于 == 和不等于 !=。例如：
1
2
3
4
5
6
7
8
9
10
11
let a = 10
let b = 20
let c = a < b // c = true
let x = 3
let y = 4
let z = x <= y // z = true
let m = 20
let n = 7
let p = m == n // p = false
比较运算符通常用于条件语句中，如 if 语句、while 循环等，以及用于排序、查找等算法中。
三目条件运算符
Swift 中的三目条件运算符 ? : 用于在两个值之间进行选择。其基本语法如下：
1
condition ? expression1 : expression2
其中 condition 是一个布尔表达式，如果为 true，则返回 expression1 的值，否则返回 expression2 的值。例如：
1
2
3
let a = 10
let b = 20
let c = a > b ? a : b // c = 20
在上面的例子中，如果 a 大于 b，则返回 a 的值，否则返回 b 的值。
空合并运算符
Swift 中的空合并运算符 ?? 用于处理可选类型的值。当一个可选类型的值为空时，可以使用空合并运算符来提供一个默认值，避免空值引起的异常。其基本语法如下：
1
optionalValue ?? defaultValue
其中 optionalValue 是一个可选类型的值，如果有值则返回该值，否则返回 defaultValue。例如：
1
2
let optionalString: String? = nil
let result = optionalString ?? "Hello" // result = "Hello"
在上面的例子中，由于 optionalString 为空，因此返回了默认值 "Hello"。
区间运算符
Swift 中的区间运算符包括闭区间运算符和半开区间运算符，用于表示一定范围内的值。闭区间运算符用 ... 表示，包含指定范围内所有的值；半开区间运算符用 ..< 表示，包含左侧的值但不包含右侧的值。例如：
1
2
let closedRange = 1...5 // 包含 1、2、3、4、5 这五个数
let halfOpenRange = 1..<5 // 包含 1、2、3、4 这四个数
区间运算符常用于循环遍历等场景中。
位运算符
Swift 中的位运算符用于对二进制数进行操作。常见的位运算符包括按位取反 ~、按位与 &、按位或 |、按位异或 ^、左移运算符 << 和右移运算符 >>。例如：
1
2
3
4
5
6
7
8
let a: UInt8 = 0b00001111
let b: UInt8 = 0b11110000
let c = ~a // c = 0b11110000
let d = a & b // d = 0b00000000
let e = a | b // e = 0b11111111
let f = a ^ b // f = 0b11111111
let g = b << 2 // g = 0b11000000
let h = b >> 2 // h = 0b00111100
在上面的例子中，我们定义了两个二进制数 a 和 b，然后对它们进行了按位取反、按位与、按位或、按位异或、左移和右移等操作。
溢出运算符
Swift 中的溢出运算符用于处理数值超过数据类型所能容纳范围的情况。Swift 提供了一系列溢出运算符，包括加法溢出运算符 &+、减法溢出运算符 &-、乘法溢出运算符 &* 和除法溢出运算符 &/，以及对应的复合赋值运算符。例如：
1
2
3
4
5
6
7
8
9
var a: Int8 = 127
a = a &+ 1 // a = -128
var b: Int8 = -128
b = b &- 1 // b = 127
var c: Int8 = 10
var d: Int8 = 20
let (e, overflow) = c.multipliedReportingOverflow(by: d) // e = 200, overflow = false
在上面的例子中，我们分别使用了加法溢出运算符、减法溢出运算符、乘法溢出运算符和除法溢出运算符对数值进行了操作，并用 multipliedReportingOverflow(by:) 方法来检查是否发生了溢出。
运算符重载
Swift 中的运算符可以通过运算符重载来自定义类型的行为。例如，我们可以为一个自定义的结构体添加加法运算符 +，来实现两个结构体相加的功能。运算符重载通常用于自定义类型的数学运算、比较和逻辑运算等操作。例如：
1
2
3
4
5
6
7
8
9
10
11
struct Vector2D {
var x = 0.0, y = 0.0
}
func +(lhs: Vector2D, rhs: Vector2D) -> Vector2D {
return Vector2D(x: lhs.x + rhs.x, y: lhs.y + rhs.y)
}
let v1 = Vector2D(x: 1.0, y: 2.0)
let v2 = Vector2D(x: 3.0, y: 4.0)
let v3 = v1 + v2 // v3 = Vector2D(x: 4.0, y: 6.0)
在上面的例子中，我们为自定义的结构体 Vector2D 添加了加法运算符 +，并实现了两个向量相加的操作。
运算符函数
运算符函数是指用来实现运算符功能的函数。在 Swift 中，可以将一些函数定义为运算符函数，并将其作为运算符使用。
例如，以下代码定义了一个名为 +* 的运算符函数，它接受三个参数：两个 Double 值和一个 Float 值。该函数将前两个值相加，然后再乘以第三个值：
1
2
3
4
5
func +*(left: Double, right: Double, factor: Float) -> Double {
return (left + right) * Double(factor)
}
let result = 2.0 +* 3.0, 1.5 // 等于 7.5
上述代码中，我们定义了一个名为 +* 的运算符函数，它接受三个参数：两个 Double 值和一个 Float 值。该函数将前两个值相加，然后再乘以第三个值。最后，我们使用 +* 运算符对两个数进行运算。
自定义运算符
除了运算符重载外，Swift 还提供了一种更加灵活和强大的方式来自定义运算符，即自定义运算符。使用 operator 关键字声明一个新的运算符，然后使用 prefix, infix 或者 postfix 修饰符来指定运算符的类型。例如：
1
2
3
4
5
6
7
8
9
10
prefix operator ++
extension Int {
static prefix func ++(value: inout Int) -> Int {
value += 1
return value
}
}
var a = 10
let b = ++a // b = 11, a = 11
在上面的例子中，我们定义了一个前缀运算符 ++，用于将一个整数加 1 并返回其值。然后通过 extension 关键字将这个运算符添加到 Int 类型中。最后，我们使用 ++ 运算符对变量 a 进行操作。