5、Swift变量、常量、字符串、运算符及集合类型学习

原创于 2025-07-17 16:52:47 发布 · 25 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#Swift # 变量 # 常量

Swift变量、常量、字符串、运算符及集合类型学习

1. 变量、常量、字符串与运算符基础

1.1 代码运行结果示例

若将某段代码放入Playground运行，会显示如下结果：

"Master Swift was published in 2015 for the price of 49.99 and has 310 pages"
"World Puzzle is a puzzle with 200 and sells for 9.99"

1.2 运算符概述

运算符是用于检查、更改或组合值的符号或符号组合。Swift支持大多数标准C运算符，并对其进行了改进，以消除一些常见的编码错误。例如，赋值运算符不会返回值，以防止在需要使用相等运算符（ == ）时误用它。

1.3 各类运算符详解

1.3.1 赋值运算符

赋值运算符用于初始化或更新变量。
- 原型： varA = varB
- 示例：

let x = 1
var y = "Hello"
a = b

1.3.2 比较运算符

比较运算符根据语句的真假返回布尔值 true 或 false 。
| 比较关系 | 原型 | 示例 | 结果 |
| ---- | ---- | ---- | ---- |
| 相等 | varA == varB | 2 == 1 | false |
| 不相等 | varA != varB | 2 != 1 | true |
| 大于 | varA > varB | 2 > 1 | true |
| 小于 | varA < varB | 2 < 1 | false |
| 大于等于 | varA >= varB | 2 >= 1 | true |
| 小于等于 | varA <= varB | 2 <= 1 | false |

1.3.3 算术运算符

算术运算符执行四种基本数学运算。
| 运算类型 | 原型 | 示例 | 结果 |
| ---- | ---- | ---- | ---- |
| 加法 | varA + varB | var x = 4 + 2 | 6 |
| 减法 | varA - varB | var x = 4 - 2 | 2 |
| 乘法 | varA * varB | var x = 4 * 2 | 8 |
| 除法 | varA / varB | var x = 4 / 2 | 2 |
| 字符串拼接 | varA + varB | var x = "Hello " + "world" | “Hello World” |

1.3.4 余数运算符

余数运算符计算第一个操作数除以第二个操作数的余数。
- 原型： varA % varB
- 示例：

var x = 10 % 3  //x will equal 1
var x = 10 % 2.6  //x will equal 2.2

1.3.5 递增和递减运算符

递增和递减运算符是将变量加1或减1的快捷方式。
| 运算符 | 作用 | 示例 | 结果 |
| ---- | ---- | ---- | ---- |
| ++varA | 先递增 varA 的值，再返回该值 | var x = 5; var y = ++x | x 和 y 都为6 |
| varA++ | 先返回 varA 的值，再递增 varA | var x = 5; var y = x++ | x 为6， y 为5 |
| --varA | 先递减 varA 的值，再返回该值 | var x = 5; var y = --x | x 和 y 都为4 |
| varA-- | 先返回 varA 的值，再递减 varA | var x = 5; var y = x-- | x 为4， y 为5 |

1.3.6 复合赋值运算符

复合赋值运算符将算术运算符与赋值运算符结合。
| 运算符 | 示例 | 结果 |
| ---- | ---- | ---- |
| varA += varB | var x = 6; x += 2 | x 为8 |
| varA -= varB | var x = 6; x -= 2 | x 为4 |
| varA *= varB | var x = 6; x *= 2 | x 为12 |
| varA /= varB | var x = 6; x /= 2 | x 为3 |

1.3.7 三元条件运算符

三元条件运算符根据比较运算符或布尔值的计算结果为变量赋值。
- 原型： (boolValue ? valueA : valueB)
- 示例：

var x = 2
var y = 3
var z = (y > x ? "Y is greater" : "X is greater")  //z equals "Y is greater"

1.3.8 逻辑非运算符

逻辑非运算符反转布尔值。
- 原型： varA = !varB
- 示例：

var x = true
var y = !x  //y equals false

1.3.9 逻辑与运算符

逻辑与运算符只有当两个操作数都为 true 时才返回 true ，否则返回 false 。
- 原型： varA && varB
- 示例：

var x = true
var y = false
var z = x && y  //z equals false

1.3.10 逻辑或运算符

逻辑或运算符只要有一个操作数为 true 就返回 true 。
- 原型： varA || varB
- 示例：

var x = true
var y = false
var z = x || y  //z equals true

1.4 总结

这些运算符对于熟悉C及类似语法语言的人来说应该很熟悉，对于不太熟悉的人，多使用后也会变得自然。理解这些概念对于编写应用程序至关重要，它们是构建所有应用程序的基础。

2. Swift集合类型与Cocoa数据类型

2.1 集合类型概述

在开发过程中，使用变量存储大量数据会变得繁琐，而集合类型可以更方便地存储相关数据。Swift提供了三种原生集合类型：数组、集合和字典。
- 数组：按顺序存储相同类型的数据。
- 集合：无序存储唯一的数据。
- 字典：无序存储键值对。

2.2 数组的特点与使用

2.2.1 数组的定义与初始化

使用数组字面量初始化 ：

let arrayOne = [1,2,3] // 定义一个不可变整数数组
var arrayTwo = [4,5,6] // 定义一个可变整数数组

创建空数组 ：

var arrayThree = [Int]() // 创建一个可存储整数的空数组

使用特殊类型别名 ：

var myArray: [AnyObject] = [1,"Two"] // 定义元素类型不同的数组

初始化指定大小和默认值的数组 ：

var arrayFour = [Int](count: 7, repeatedValue: 3) // 定义一个包含7个元素，每个元素值为3的数组

创建多维数组 ：

var multiArrayOne = [[1,2],[3,4],[5,6]]
var multiArrayTwo = [[Int]]()

2.2.2 数组元素的访问

使用下标语法 ：

let arrayOne = [1,2,3,4,5,6]
print(arrayOne[0])  //Displays '1'
print(arrayOne[3])  //Displays '4'

访问多维数组元素 ：

var multiArray = [[1,2],[3,4],[5,6]]
var arr = multiArray[0] //arr contains the array [1,2]
var value = multiArray[0][1] //value contains 2

使用 first 和 last 属性 ：

let arrayOne = [1,2,3,4,5,6]
var first = arrayOne.first  //first contains 1
var last = arrayOne.last  //last contains 6
let multiArray = [[1,2],[3,4],[5,6]]
var arrFirst1 = multiArray[0].first //arrFirst1 contains 1
var arrFirst2 = multiArray.first //arrFirst2 contains[1,2]
var arrLast1 = multiArray[0].last //arrLast1 contains 2
var arrLast2 = multiArray.last  //arrLast2 contains [5,6]

2.2.3 数组元素的计数

使用 count 属性获取数组元素的数量。

let arrayOne = [1,2,3]
let multiArrayOne = [[3,4],[5,6],[7,8]]
print(arrayOne.count)  //Displays 3
print(multiArrayOne.count)  //Displays 3 for the three arrays
print(multiArrayOne[0].count)  //Displays 2 for the two elements

需要注意， count 属性返回的是数组元素的数量，而不是最大有效索引。对于非空数组，最大有效索引是元素数量减1。

2.2.4 数组边界检查

如果使用下标语法访问数组元素时，索引超出数组范围，应用程序会抛出 Array index out of range 错误。因此，在不确定数组大小时，应先检查索引是否在有效范围内。

//This example will throw an array index out of range error
var arrayTwo = [1,2,3,4]
print(arrayTwo[6])
//This example will not throw an array index out of range error
var arrayOne = [1,2,3,4]
if (arrayOne.count> 6) {
    print(arrayOne[6])
}

2.2.5 检查数组是否为空

使用 isEmpty 属性检查数组是否为空。

var arrayOne = [1,2]
var arrayTwo = [Int]()
arrayOne.isEmpty  //Returns false because the array is not empty
arrayTwo.isEmpty  //Returns true because the array is empty

2.2.6 数组元素的添加

使用 append 方法 ：

var arrayOne = [1,2]
arrayOne.append(3)  //arrayOne will now contain 1, 2 and 3

使用加法赋值运算符 += ：

var arrayOne = [1,2]
arrayOne += [3,4]  //arrayOne will now contain 1, 2, 3 and 4

2.2.7 数组元素的插入

使用 insert 方法在指定索引处插入值。

var arrayOne = [1,2,3,4,5]
arrayOne.insert(10, atIndex: 3) //arrayOne now contains 1, 2, 3, 10, 4 and 5

需要注意，不能在超出当前数组范围的索引处插入值，否则会抛出 Index out of range 异常。

2.2.8 数组元素的替换

使用下标语法和赋值运算符替换数组元素。

var arrayOne = [1,2,3]
arrayOne[1] = 10  //arrayOne now contains 1,10,3

2.3 总结

掌握这些集合类型的使用方法，可以更高效地存储和管理数据，提高开发效率。后续还可以进一步学习如何使用Cocoa和Foundation数据类型。

2.4 集合的特点与使用

2.4.1 集合的定义与初始化

集合是无序且元素唯一的数据结构。在 Swift 中，创建集合需要明确指定元素类型。

var setOne: Set<Int> = [1, 2, 3] // 定义一个整数集合
var setTwo = Set<Double>() // 创建一个可存储双精度浮点数的空集合

2.4.2 集合元素的操作

添加元素 ：使用 insert 方法添加元素，如果元素已存在则不会重复添加。

var setOne: Set<Int> = [1, 2, 3]
setOne.insert(4) // setOne 现在包含 1, 2, 3, 4

移除元素 ：使用 remove 方法移除指定元素。

setOne.remove(2) // setOne 现在包含 1, 3, 4

检查元素是否存在 ：使用 contains 方法检查集合中是否包含某个元素。

let containsTwo = setOne.contains(2) // containsTwo 为 false

2.4.3 集合的基本运算

交集：使用 intersection 方法获取两个集合的交集。

let setA: Set<Int> = [1, 2, 3]
let setB: Set<Int> = [3, 4, 5]
let intersectionSet = setA.intersection(setB) // intersectionSet 包含 3

并集：使用 union 方法获取两个集合的并集。

let unionSet = setA.union(setB) // unionSet 包含 1, 2, 3, 4, 5

差集：使用 subtracting 方法获取两个集合的差集。

let subtractingSet = setA.subtracting(setB) // subtractingSet 包含 1, 2

2.5 字典的特点与使用

2.5.1 字典的定义与初始化

字典用于存储键值对，键必须是唯一的。

let dictOne = ["name": "John", "age": 25] // 定义一个不可变字典
var dictTwo = [String: Int]() // 创建一个可存储字符串键和整数值的空字典

2.5.2 字典元素的访问与修改

访问元素 ：使用键来访问字典中的值，返回的是可选类型。

let name = dictOne["name"] // name 为 "John"

修改元素 ：使用键和赋值运算符修改字典中的值。

dictTwo["score"] = 80 // dictTwo 现在包含键值对 "score": 80

添加元素 ：如果键不存在，使用键和赋值运算符添加新的键值对。

dictTwo["rank"] = 5 // dictTwo 现在包含 "score": 80, "rank": 5

移除元素 ：使用 removeValue(forKey:) 方法移除指定键的键值对。

dictTwo.removeValue(forKey: "score") // dictTwo 现在只包含 "rank": 5

2.6 元组的特点与使用

2.6.1 元组的定义与初始化

元组是一种可以包含不同类型值的复合数据类型。

let tupleOne = (1, "Hello") // 定义一个包含整数和字符串的元组

2.6.2 元组元素的访问

使用索引访问 ：可以使用索引来访问元组中的元素。

let firstValue = tupleOne.0 // firstValue 为 1

使用命名元素访问 ：也可以在定义元组时为元素命名，然后使用名称访问。

let tupleTwo = (name: "Alice", age: 30)
let personName = tupleTwo.name // personName 为 "Alice"

2.7 Cocoa 和 Foundation 数据类型的使用

在 Swift 中，可以使用 Cocoa 和 Foundation 框架提供的数据类型。这些数据类型提供了更丰富的功能和更广泛的兼容性。

2.7.1 使用 NSString

NSString 是 Foundation 框架中的字符串类，与 Swift 的 String 类型可以相互转换。

let swiftString = "Hello"
let nsString: NSString = swiftString as NSString
let newSwiftString = nsString as String

2.7.2 使用 NSArray 和 NSMutableArray

NSArray 是不可变数组， NSMutableArray 是可变数组。

let nsArray: NSArray = [1, 2, 3]
let mutableArray = NSMutableArray(array: [4, 5, 6])
mutableArray.add(7) // mutableArray 现在包含 4, 5, 6, 7

2.8 总结

通过学习 Swift 的变量、常量、字符串、运算符以及各种集合类型和 Cocoa 数据类型，我们掌握了构建应用程序的基础。这些知识为我们进一步开发复杂的应用程序提供了强大的工具。以下是一个简单的流程图，展示了选择合适集合类型的思路：

graph TD;
    A[需要存储数据] --> B{数据是否有序};
    B -- 是 --> C{元素类型是否相同};
    C -- 是 --> D[使用数组];
    C -- 否 --> E[使用元组或 AnyObject 数组];
    B -- 否 --> F{元素是否唯一};
    F -- 是 --> G[使用集合];
    F -- 否 --> H{是否需要键值对};
    H -- 是 --> I[使用字典];
    H -- 否 --> J[使用其他数据结构];

在实际开发中，我们应根据具体需求选择合适的数据类型和运算符，以提高代码的效率和可维护性。同时，不断实践和探索这些知识，将有助于我们成为更优秀的开发者。