Swift运算符与表达式实践

Swift运算符概述

在Swift编程中，运算符是执行特定操作的符号。它们用于对值、变量或表达式进行计算或操作。Swift提供了丰富的运算符，包括算术运算符、比较运算符、逻辑运算符、位运算符等。了解这些运算符及其行为对于编写高效且正确的Swift代码至关重要。

算术运算符

1. 基本算术运算符
   • 加法（+）：用于将两个值相加。例如：

let num1 = 5
let num2 = 3
let sum = num1 + num2
print(sum) // 输出8

- **减法（-）**：计算两个值的差。示例：

let difference = num1 - num2
print(difference) // 输出2

- **乘法（*）**：实现两个值的相乘。如下：

let product = num1 * num2
print(product) // 输出15

- **除法（/）**：对两个值进行除法运算。注意，对于整数类型，结果会截断为整数。例如：

let quotient = num1 / num2
print(quotient) // 输出1，因为5 / 3 = 1.666...，截断后为1

- **取余（%）**：返回除法运算的余数。代码如下：

let remainder = num1 % num2
print(remainder) // 输出2，因为5除以3余数为2

2. 自增和自减运算符
   • 自增（++）：有前置和后置两种形式。前置自增（++a）先将变量的值加1，然后返回新的值；后置自增（a++）先返回变量原来的值，然后再将变量的值加1。示例：

var a = 5
let b = ++a
print(b) // 输出6，此时a的值也变为6
var c = 5
let d = c++
print(d) // 输出5，此时c的值变为6

- **自减（--）**：同样有前置和后置形式。前置自减（--a）先将变量的值减1，然后返回新的值；后置自减（a--）先返回变量原来的值，然后再将变量的值减1。例如：

var e = 5
let f = --e
print(f) // 输出4，此时e的值也变为4
var g = 5
let h = g--
print(h) // 输出5，此时g的值变为4

比较运算符

1. 相等（==）和不等（!=）
   • 相等（==）：用于判断两个值是否相等。示例：

let num3 = 10
let num4 = 10
let isEqual = num3 == num4
print(isEqual) // 输出true

- **不等（!=）**：判断两个值是否不相等。例如：

let isNotEqual = num3 != num4
print(isNotEqual) // 输出false

2. 大于（>）、小于（<）、大于等于（>=）和小于等于（<=）
   • 大于（>）：判断左边的值是否大于右边的值。例如：

let num5 = 15
let num6 = 10
let isGreater = num5 > num6
print(isGreater) // 输出true

- **小于（<）**：判断左边的值是否小于右边的值。代码如下：

let isLess = num5 < num6
print(isLess) // 输出false

- **大于等于（>=）**：判断左边的值是否大于或等于右边的值。示例：

let num7 = 10
let num8 = 10
let isGreaterOrEqual = num7 >= num8
print(isGreaterOrEqual) // 输出true

- **小于等于（<=）**：判断左边的值是否小于或等于右边的值。例如：

let isLessOrEqual = num7 <= num8
print(isLessOrEqual) // 输出true

逻辑运算符

1. 逻辑与（&&）：只有当两个操作数都为true时，结果才为true。示例：

let condition1 = true
let condition2 = false
let result1 = condition1 && condition2
print(result1) // 输出false

2. 逻辑或（||）：只要两个操作数中有一个为true，结果就为true。例如：

let result2 = condition1 || condition2
print(result2) // 输出true

3. 逻辑非（!）：用于对一个布尔值取反。如果操作数为true，则结果为false；反之，如果操作数为false，则结果为true。代码如下：

let result3 =!condition1
print(result3) // 输出false

位运算符

1. 按位与（&）：对两个整数的每一位进行与操作。只有当对应位都为1时，结果位才为1。示例：

let number1: UInt8 = 5 // 二进制为00000101
let number2: UInt8 = 3 // 二进制为00000011
let bitwiseAndResult = number1 & number2
print(bitwiseAndResult) // 输出1，二进制为00000001

2. 按位或（|）：对两个整数的每一位进行或操作。只要对应位中有一个为1，结果位就为1。例如：

let bitwiseOrResult = number1 | number2
print(bitwiseOrResult) // 输出7，二进制为00000111

3. 按位异或（^）：对两个整数的每一位进行异或操作。当对应位不同时，结果位为1；相同时，结果位为0。代码如下：

let bitwiseXorResult = number1 ^ number2
print(bitwiseXorResult) // 输出6，二进制为00000110

4. 按位取反（~）：对一个整数的每一位进行取反操作。1变为0，0变为1。示例：

let number3: UInt8 = 5 // 二进制为00000101
let bitwiseNotResult = ~number3
print(bitwiseNotResult) // 输出250，二进制为11111010

5. 左移（<<）和右移（>>）
   • 左移（<<）：将一个整数的二进制表示向左移动指定的位数，右边补0。例如：

let number4: UInt8 = 5 // 二进制为00000101
let leftShiftResult = number4 << 2
print(leftShiftResult) // 输出20，二进制为00010100

- **右移（>>）**：将一个整数的二进制表示向右移动指定的位数。对于无符号整数，左边补0；对于有符号整数，左边补符号位。示例：

let number5: UInt8 = 20 // 二进制为00010100
let rightShiftResult = number5 >> 2
print(rightShiftResult) // 输出5，二进制为00000101

赋值运算符

1. 简单赋值（=）：将右边的值赋给左边的变量。例如：

var variable1 = 10

2. 复合赋值运算符
   • 加法赋值（+=）：将右边的值加到左边的变量上，并将结果赋给左边的变量。示例：

var variable2 = 5
variable2 += 3
print(variable2) // 输出8

- **减法赋值（-=）**：从左边的变量中减去右边的值，并将结果赋给左边的变量。例如：

variable2 -= 2
print(variable2) // 输出6

- **乘法赋值（*=）**：将左边的变量与右边的值相乘，并将结果赋给左边的变量。代码如下：

variable2 *= 3
print(variable2) // 输出18

- **除法赋值（/=）**：用左边的变量除以右边的值，并将结果赋给左边的变量。示例：

variable2 /= 2
print(variable2) // 输出9

- **取余赋值（%=）**：将左边的变量对右边的值取余，并将结果赋给左边的变量。例如：

variable2 %= 4
print(variable2) // 输出1

三元条件运算符

三元条件运算符（? :）是一种简洁的条件判断方式。它的语法为condition? value1 : value2，如果condition为true，则返回value1；否则返回value2。示例：

let num9 = 10
let num10 = 20
let maxNumber = num9 > num10? num9 : num10
print(maxNumber) // 输出20

区间运算符

1. 闭区间运算符（...）：用于定义一个包含起始值和结束值的闭区间。例如：

let closedRange = 1...5
for number in closedRange {
    print(number) 
    // 输出1, 2, 3, 4, 5
}

2. 半开区间运算符（..<）：定义一个包含起始值但不包含结束值的半开区间。示例：

let halfOpenRange = 1..<5
for number in halfOpenRange {
    print(number) 
    // 输出1, 2, 3, 4
}

3. 单侧区间：可以使用...或..<与单个值结合，形成单侧区间。例如，...5表示从负无穷到5的区间，5...表示从5到正无穷的区间，5..<同样表示从5到正无穷的区间。单侧区间在某些集合操作中很有用，比如从数组的某个索引开始获取元素。

运算符优先级和结合性

1. 优先级：运算符的优先级决定了表达式中不同运算符的计算顺序。例如，乘法和除法的优先级高于加法和减法。在表达式2 + 3 * 4中，先计算3 * 4，然后再加上2，结果为14。
2. 结合性：结合性决定了相同优先级运算符的计算方向。大多数二元运算符是左结合的，即从左到右计算。例如，在表达式10 / 2 * 5中，先计算10 / 2，得到5，然后再乘以5，结果为25。但是，赋值运算符是右结合的，如a = b = c，先将c的值赋给b，然后再将b的值赋给a。

自定义运算符

在Swift中，你还可以定义自己的运算符。首先，使用operator关键字声明运算符，并指定其前缀、中缀或后缀形式。例如，定义一个自定义的中缀运算符+~：

infix operator +~: AdditionPrecedence
func +~(left: Int, right: Int) -> Int {
    return left + right * 2
}
let result4 = 3 +~ 4
print(result4) // 输出11，因为3 + 4 * 2 = 11

在这个例子中，我们定义了一个中缀运算符+~，它的优先级与AdditionPrecedence相同，并且实现了一种自定义的计算逻辑。

表达式

1. 简单表达式：由单个值、变量或常量组成。例如：

let value = 10
let simpleExpression = value
print(simpleExpression) // 输出10

2. 复合表达式：由多个运算符和操作数组成。例如：

let complexExpression = (2 + 3) * (4 - 1)
print(complexExpression) // 输出15

3. 函数调用表达式：调用函数也是一种表达式。例如：

func addNumbers(_ a: Int, _ b: Int) -> Int {
    return a + b
}
let functionCallExpression = addNumbers(5, 3)
print(functionCallExpression) // 输出8

4. 条件表达式：使用三元条件运算符或if - else语句构成的表达式。例如：

let num11 = 10
let num12 = 5
let conditionalExpression = num11 > num12? "num11 is greater" : "num12 is greater or equal"
print(conditionalExpression) // 输出num11 is greater

在Swift编程中，深入理解运算符和表达式的使用是编写高效、正确代码的基础。通过合理运用各种运算符和构建复杂的表达式，可以实现各种复杂的逻辑和功能。无论是开发简单的iOS应用程序，还是进行复杂的后端开发，这些知识都将发挥重要作用。同时，注意运算符的优先级、结合性以及自定义运算符的规则，能够避免代码中的潜在错误，提高代码的可读性和可维护性。