当前位置：首页 > news >正文

Swift的学习笔记（一）

news 来源：原创 2025/9/10 13:06:05

Swift的学习笔记（一）

文章目录

Swift的学习笔记（一）
- 元组
- - 基本语法
  - 1. **创建元组**
  - 2. **访问元组的值**
  - 3. **命名的元组**
  - 4. **解构元组**
  - 5. **忽略某些值**
- 可选值类型
- - 定义 Optional
  - Optional 的基本使用
  - - 1. **给 Optional 赋值和取值**
    - 2. **强制解包（Force Unwrapping）**
  - if let语句的使用
- 空合并运算符
- - **基本示例**
- guard的使用
- 循环的写法
- - Switch…case
  - - 使用元组匹配
    - 条件匹配（`where`）
  - **数组的创建**
  - - 方式 1：使用字面量
    - 方式 2：显式指定类型
    - 方式 3：空数组
    - 方式 4：创建具有默认值的数组
  - **数组的高级操作**
  - - 1. **过滤（filter）**
    - 2. **映射（map）**
    - 3. **归约（reduce）**
    - 4. **排序（sorted 和 sort）**
- 跳转语句
- - break跳出多重循环
  - - **语法**：
    - 输出：

元组

元组（Tuple）是 Swift 中的一种强大的数据结构，用于将多个值组合成一个复合值。元组的内容可以是任意类型（不同类型的值可以组合在一起），并且每个值都可以有名称或只是位置。

基本语法

元组用圆括号 () 包裹值，多个值之间用逗号 , 分隔。

1. 创建元组

let person = ("John", 28)

上面的例子创建了一个元组，包含一个字符串 "John" 和一个整数 28。

2. 访问元组的值

元组的值可以通过 位置索引 或名称来访问：

let person = ("John", 28)// 使用位置索引
print(person.0)  // 输出 "John"
print(person.1)  // 输出 28

3. 命名的元组

元组的元素可以有名称，这样更容易理解数据的意义：

let person = (name: "John", age: 28)// 使用名称访问
print(person.name)  // 输出 "John"
print(person.age)   // 输出 28

4. 解构元组

元组可以通过解构直接将值赋给多个变量：

let person = ("John", 28)
let (name, age) = personprint(name)  // 输出 "John"
print(age)   // 输出 28

5. 忽略某些值

如果不需要某些值，可以使用 _ 忽略：

let person = ("John", 28)
let (name, _) = personprint(name)  // 输出 "John"

注：元组虽然用起来方便，但是只能用于简单的数据整合

可选值类型

在 Swift 中，Optional 是一种用来处理可能存在 “无值” 情况的类型，它是 Swift 安全性的一部分，帮助开发者避免运行时错误（如空指针异常）。

Optional 是一个枚举，表示两种可能性：

有值（some(Value)）。
没有值（nil）。

定义 Optional

在类型后面加上一个问号（?）即可将该类型声明为 Optional：

var name: String? = nil

这意味着变量 name 可能有值，也可能是 nil。

Optional 的基本使用

1. 给 Optional 赋值和取值

var name: String? = "Alice"  // 定义一个 Optional 类型的 String
print(name)  // 输出：Optional("Alice")

2. 强制解包（Force Unwrapping）

要从 Optional 中取出实际值，可以使用感叹号（!）：

print(name!)  // 输出：Alice

⚠️ 注意： 如果 Optional 的值是 nil，强制解包会导致运行时崩溃。

if let语句的使用

if let 是 Swift 中一种常用于解包可选类型（Optional）的语法。它的作用是安全地尝试从一个可选值中提取出实际的值，如果该可选值不为 nil，则解包并将其赋值给一个新的常量或变量，供 if let 语句内部使用。若可选值为 nil，则 else 部分会被执行，或者你可以选择不执行任何操作。

var name: String? = "Alice"// 使用 if let 解包
if let unwrappedName = name {print("Hello, \(unwrappedName)!")
} else {print("Name is nil.")
}

空合并运算符

它用于处理可选类型（Optional）中的 nil 值。该运算符的作用是：如果左边的可选值不为 nil，则返回它的值；如果左边的可选值为 nil，则返回右边的默认值。

基本示例

var name: String? = "Alice"
let unwrappedName = name ?? "Unknown"
print(unwrappedName)  // 输出：Alice

在上面的例子中，name 不为 nil，所以 unwrappedName 会被赋值为 name 的值 "Alice"。

guard的使用

guard语句必须带有else语句，它的语法如下：
当条件表达式为true时候跳过else语句中的内容，执行后面的语句组
条件表达式为false时候执行else语句中的内容，跳转语句一般是return、break、continue或throw

guard 条件表达式 else {// 条换语句break
}

循环的写法

swift之中的循环和C语言的区别还是挺大的

for item in 0..<10 {print(item)
}

我们在swift之中一般只使用for—in循环

while count >= 20 {count += 1print(count)
}

关于while循环则是大差不差，另外需要提的一点是，count++这类操作在swift3已经被禁用了

至于C语言之中的do…while语句，则是用repeat…while代替

repeat {print("swift")count += 5
} while count < 30

Switch…case

使用元组匹配

switch 可以匹配元组，并结合模式匹配。

swift复制代码
let point = (2, 3)switch point {
case (0, 0):print("Origin")
case (_, 0):print("On the X-axis")
case (0, _):print("On the Y-axis")
case (-2...2, -2...2):print("Inside the box")
default:print("Outside the box")
}

输出：

Inside the box

条件匹配（`where`）

使用 where 为 case 添加额外的条件：

let number = 15switch number {
case let x where x % 2 == 0:print("\(x) is even")
case let x where x % 2 != 0:print("\(x) is odd")
default:print("Unknown")
}

输出：

15 is odd

数组

数组的创建

方式 1：使用字面量

var numbers = [1, 2, 3, 4, 5]  // 自动推断类型为 [Int]
var fruits = ["Apple", "Banana", "Cherry"]  // 自动推断类型为 [String]

方式 2：显式指定类型

var numbers: [Int] = [1, 2, 3, 4, 5]
var fruits: [String] = ["Apple", "Banana", "Cherry"]

方式 3：空数组

var emptyArray: [Int] = []  // 明确指定类型
var anotherEmptyArray = [String]()  // 使用初始化器创建

方式 4：创建具有默认值的数组

var repeatedArray = Array(repeating: 0, count: 5)  // [0, 0, 0, 0, 0]

在 Swift 中，数组（Array） 是一种用于存储同一类型值的有序集合。数组是常用的数据结构，支持动态大小调整，能够快速地添加、删除和访问元素。

数组的高级操作

1. 过滤（filter）

从数组中筛选符合条件的元素：

let numbers = [1, 2, 3, 4, 5]
let evenNumbers = numbers.filter { $0 % 2 == 0 }
print(evenNumbers)  // [2, 4]

2. 映射（map）

对数组的每个元素进行操作，生成新数组：

let numbers = [1, 2, 3]
let squaredNumbers = numbers.map { $0 * $0 }
print(squaredNumbers)  // [1, 4, 9]

3. 归约（reduce）

将数组的所有元素合并为一个值：

let numbers = [1, 2, 3, 4]
let sum = numbers.reduce(0) { $0 + $1 }
print(sum)  // 10

4. 排序（sorted 和 sort）

创建排序后的新数组：

let numbers = [4, 2, 3, 1]
let sortedNumbers = numbers.sorted()
print(sortedNumbers)  // [1, 2, 3, 4]

对原数组排序：

var numbers = [4, 2, 3, 1]
numbers.sort()
print(numbers)  // [1, 2, 3, 4]

跳转语句

Swift 提供了多种流程跳转语句，用于改变代码的执行顺序，从而实现灵活的逻辑控制。这些语句包括 continue、break、fallthrough、return、throw 和 guard。它们有些和C语言很像，因此这里仅挑几个进行讲解

break跳出多重循环

Swift 允许为循环添加标记（label），通过 break 语句可以退出指定标记的循环。

语法：

labelName: for ... {for ... {if condition {break labelName  // 跳出指定标记的循环}}
}

用例：

outerLoop: for i in 1...3 {for j in 1...3 {print("i = \(i), j = \(j)")if i == 2 && j == 2 {print("Breaking outer loop")break outerLoop  // 跳出外层循环}}
}

输出：

i = 1, j = 1
i = 1, j = 2
i = 1, j = 3
i = 2, j = 1
i = 2, j = 2
Breaking outer loop