Swift控制流与函数编程实践-优快云博客

Swift控制流与函数编程实践

本文全面探讨了Swift语言中控制流和函数式编程的核心概念与实践应用。内容涵盖了条件语句（if和switch）的详细使用方法、循环语句（for-in、while和repeat-while）的深度解析、函数的定义与参数传递机制，以及闭包的概念与实际应用场景。文章通过丰富的代码示例和最佳实践指南，帮助开发者掌握如何编写清晰、安全和高效的Swift代码。

条件语句 if 和 switch 的使用

Swift 提供了两种强大的条件语句来控制程序流程：if 语句和 switch 语句。它们各自适用于不同的场景，让代码更加清晰、安全和易于维护。

if 语句的基本用法

if 语句是编程中最基础的条件判断结构，它根据条件的真假来决定是否执行特定的代码块。

简单的 if 语句

最基本的 if 语句只包含一个条件判断：

var temperatureInFahrenheit = 30
if temperatureInFahrenheit <= 32 {
    print("It's very cold. Consider wearing a scarf.")
}
// 输出 "It's very cold. Consider wearing a scarf."

if-else 语句

当需要处理条件为假的情况时，可以使用 else 子句：

temperatureInFahrenheit = 40
if temperatureInFahrenheit <= 32 {
    print("It's very cold. Consider wearing a scarf.")
} else {
    print("It's not that cold. Wear a T-shirt.")
}
// 输出 "It's not that cold. Wear a T-shirt."

多条件判断

通过 else if 可以处理多个条件分支：

temperatureInFahrenheit = 90
if temperatureInFahrenheit <= 32 {
    print("It's very cold. Consider wearing a scarf.")
} else if temperatureInFahrenheit >= 86 {
    print("It's really warm. Don't forget to wear sunscreen.")
} else {
    print("It's not that cold. Wear a T-shirt.")
}
// 输出 "It's really warm. Don't forget to wear sunscreen."

if 表达式

Swift 5.9 引入了 if 表达式，允许在赋值时直接使用条件判断：

let temperatureInCelsius = 25
let weatherAdvice = if temperatureInCelsius <= 0 {
    "It's very cold. Consider wearing a scarf."
} else if temperatureInCelsius >= 30 {
    "It's really warm. Don't forget to wear sunscreen."
} else {
    "It's not that cold. Wear a T-shirt."
}

print(weatherAdvice)
// 输出 "It's not that cold. Wear a T-shirt."

switch 语句的强大功能

switch 语句用于将一个值与多个可能的模式进行匹配，比 if 语句更适合处理多个分支的情况。

基本 switch 语法

let someCharacter: Character = "z"
switch someCharacter {
case "a":
    print("The first letter of the Latin alphabet")
case "z":
    print("The last letter of the Latin alphabet")
default:
    print("Some other character")
}
// 输出 "The last letter of the Latin alphabet"

switch 表达式

与 if 表达式类似，switch 也支持表达式形式：

let anotherCharacter: Character = "a"
let message = switch anotherCharacter {
case "a":
    "The first letter of the Latin alphabet"
case "z":
    "The last letter of the Latin alphabet"
default:
    "Some other character"
}

print(message)
// 输出 "The first letter of the Latin alphabet"

无隐式贯穿

Swift 的 switch 语句不会像 C 语言那样隐式贯穿到下一个 case，这避免了常见的编程错误：

let anotherCharacter: Character = "a"
switch anotherCharacter {
case "a", "A":  // 使用逗号分隔多个匹配值
    print("The letter A")
default:
    print("Not the letter A")
}
// 输出 "The letter A"

区间匹配

switch 语句支持区间匹配，非常适合处理数值范围：

let approximateCount = 62
let countedThings = "moons orbiting Saturn"
let naturalCount: String

switch approximateCount {
case 0:
    naturalCount = "no"
case 1..<5:
    naturalCount = "a few"
case 5..<12:
    naturalCount = "several"
case 12..<100:
    naturalCount = "dozens of"
case 100..<1000:
    naturalCount = "hundreds of"
default:
    naturalCount = "many"
}

print("There are \(naturalCount) \(countedThings).")
// 输出 "There are dozens of moons orbiting Saturn."

元组匹配

switch 可以匹配元组值，实现多维条件判断：

let somePoint = (1, 1)
switch somePoint {
case (0, 0):
    print("\(somePoint) is at the origin")
case (_, 0):
    print("\(somePoint) is on the x-axis")
case (0, _):
    print("\(somePoint) is on the y-axis")
case (-2...2, -2...2):
    print("\(somePoint) is inside the box")
default:
    print("\(somePoint) is outside of the box")
}
// 输出 "(1, 1) is inside the box"

值绑定

可以在 case 中绑定匹配的值到临时变量：

let anotherPoint = (2, 0)
switch anotherPoint {
case (let x, 0):
    print("on the x-axis with an x value of \(x)")
case (0, let y):
    print("on the y-axis with a y value of \(y)")
case let (x, y):
    print("somewhere else at (\(x), \(y))")
}
// 输出 "on the x-axis with an x value of 2"

Where 子句

使用 where 子句添加额外的匹配条件：

let yetAnotherPoint = (1, -1)
switch yetAnotherPoint {
case let (x, y) where x == y:
    print("(\(x), \(y)) is on the line x == y")
case let (x, y) where x == -y:
    print("(\(x), \(y)) is on the line x == -y")
case let (x, y):
    print("(\(x), \(y)) is just some arbitrary point")
}
// 输出 "(1, -1) is on the line x == -y"

复合 Cases

多个 case 可以共享同一个执行体：

let someCharacter: Character = "e"
switch someCharacter {
case "a", "e", "i", "o", "u":
    print("\(someCharacter) is a vowel")
case "b", "c", "d", "f", "g", "h", "j", "k", "l", "m",
     "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z":
    print("\(someCharacter) is a consonant")
default:
    print("\(someCharacter) isn't a vowel or a consonant")
}
// 输出 "e is a vowel"

选择指南：if vs switch

场景	推荐使用	原因
简单条件判断	if	代码简洁，易于理解
2-3 个分支	if-else	结构清晰，无需复杂语法
多个离散值匹配	switch	可读性好，避免深层嵌套
区间匹配	switch	原生支持区间语法
元组匹配	switch	支持多维条件判断
模式匹配	switch	支持值绑定和 where 子句
表达式赋值	if/switch 表达式	代码更简洁，减少临时变量

最佳实践

优先使用 switch 当处理多个离散值时，switch 语句更加清晰和安全
避免深层嵌套 如果 if 语句嵌套超过3层，考虑使用 switch 或重构代码
利用完备性检查 switch 的完备性要求可以避免遗漏处理的情况
使用 guard 提前返回 对于前置条件检查，guard 语句比 if 更合适
保持代码可读性 复杂的条件判断应该添加注释说明业务逻辑

mermaid

通过合理选择 if 和 switch 语句，可以编写出更加清晰、安全和易于维护的 Swift 代码。switch 语句的强大模式匹配能力使其成为处理复杂条件判断的理想选择，而 if 语句则在简单条件判断时保持代码的简洁性。

Swift循环语句：for-in、while和repeat-while深度解析

Swift提供了三种强大的循环结构来满足不同的编程需求：for-in循环用于遍历序列和集合，while循环用于条件驱动的迭代，以及repeat-while循环确保至少执行一次循环体。这些循环结构不仅语法简洁，还提供了丰富的控制能力。

for-in循环：序列遍历的利器

for-in循环是Swift中最常用的循环结构，专门设计用于遍历序列、集合和范围。其基本语法如下：

for item in collection {
    // 处理每个item
}

遍历数组和字典

// 遍历数组
let fruits = ["苹果", "香蕉", "橙子", "葡萄"]
for fruit in fruits {
    print("我喜欢吃\(fruit)")
}

// 遍历字典
let studentScores = ["张三": 85, "李四": 92, "王五": 78]
for (name, score) in studentScores {
    print("\(name)的分数是\(score)")
}

范围遍历和步进控制

Swift提供了灵活的范围操作符和步进函数：

// 闭区间遍历
for number in 1...5 {
    print("数字: \(number)")
}

// 半开区间遍历
for index in 0..<5 {
    print("索引: \(index)")
}

// 使用stride进行步进控制
for hour in stride(from: 0, to: 24, by: 3) {
    print("每3小时: \(hour)点")
}

for minute in stride(from: 0, through: 60, by: 15) {
    print("每15分钟: \(minute)分")
}

忽略循环变量

当不需要使用循环变量时，可以使用下划线忽略：

var result = 1
let base = 2
let exponent = 10

for _ in 1...exponent {
    result *= base
}
print("\(base)的\(exponent)次方是\(result)")

while循环：条件驱动的迭代

while循环在每次迭代开始时检查条件，适合迭代次数不确定的场景：

var counter = 0
while counter < 5 {
    print("计数器: \(counter)")
    counter += 1
}

游戏示例

let finalSquare = 25
var board = [Int](repeating: 0, count: finalSquare + 1)

// 设置特殊位置
board[03] = +08; board[06] = +11; board[09] = +09; board[10] = +02
board[14] = -10; board[19] = -11; board[22] = -02; board[24] = -08

var square = 0
var diceRoll = 0

while square < finalSquare {
    // 模拟掷骰子
    diceRoll += 1
    if diceRoll == 7 { diceRoll = 1 }
    
    // 移动玩家
    square += diceRoll
    
    if square < board.count {
        // 处理特殊位置
        square += board[square]
    }
}
print("游戏结束!")

repeat-while循环：确保至少执行一次

repeat-while循环先执行循环体，再检查条件，确保循环体至少执行一次：

var number = 1
repeat {
    print("数字: \(number)")
    number += 1
} while number <= 5

改进的游戏实现

repeat {
    // 先处理当前位置的特殊位置
    square += board[square]
    
    // 然后掷骰子移动
    diceRoll += 1
    if diceRoll == 7 { diceRoll = 1 }
    square += diceRoll
} while square < finalSquare

循环控制语句

Swift提供了break和continue语句来控制循环流程：

// continue示例：跳过元音字母
let phrase = "Hello Swift Programming"
var output = ""

for character in phrase {
    switch character {
    case "a", "e", "i", "o", "u", " ":
        continue  // 跳过元音和空格
    default:
        output.append(character)
    }
}
print("处理后的字符串: \(output)")

// break示例：提前退出循环
var found = false
var target = 42
var numbers = [10, 25, 42, 67, 89]

for number in numbers {
    if number == target {
        found = true
        break  // 找到目标，立即退出循环
    }
}
print("是否找到目标: \(found)")

带标签的循环

对于嵌套循环，可以使用标签来明确控制break和continue的作用范围：

outerLoop: for i in 1...3 {
    innerLoop: for j in 1...3 {
        if i * j == 6 {
            print("找到乘积为6的组合: \(i) × \(j)")
            break outerLoop  // 退出外层循环
        }
        print("当前乘积: \(i) × \(j) = \(i * j)")
    }
}

循环性能优化技巧

使用lazy序列处理大数据集

let largeArray = Array(1...1_000_000)

// 使用lazy延迟计算，避免创建中间数组
let result = largeArray.lazy
    .filter { $0 % 2 == 0 }
    .map { $0 * 2 }
    .prefix(10)

for value in result {
    print(value)
}

避免在循环中创建不必要的对象

// 不推荐的写法：每次循环都创建新字符串
var messages: [String] = []
for i in 1...1000 {
    messages.append("消息\(i)")  // 每次循环创建新字符串
}

// 推荐的写法：使用字符串插值或格式化
var optimizedMessages: [String] = []
let template = "消息%d"
for i in 1...1000 {
    optimizedMessages.append(String(format: template, i))
}

循环模式对比

下表总结了三种循环结构的特点和适用场景：

循环类型	语法	执行特点	适用场景
for-in	`for item in collection`	遍历序列中的每个元素	数组、字典、范围遍历
while	`while condition`	先检查条件后执行	迭代次数不确定
repeat-while	`repeat {...} while condition`	先执行后检查条件	至少执行一次的场景

实际应用场景

文件处理循环

import Foundation

let fileManager = FileManager.default
let documentsURL = fileManager.urls(for: .documentDirectory, in: .userDomainMask)[0]

do {
    let fileURLs = try fileManager.contentsOfDirectory(at: documentsURL, 
                                                     includingPropertiesForKeys: nil)
    
    // 使用for-in遍历文件
    for fileURL in fileURLs {
        if fileURL.pathExtension == "txt" {
            print("找到文本文件: \(fileURL.lastPathComponent)")
        }
    }
} catch {
    print("文件处理错误: \(error)")
}

网络请求重试机制

var attempt = 0
let maxAttempts = 3
var success = false

repeat {
    attempt += 1
    print("尝试第\(attempt)次网络请求...")
    
    // 模拟网络请求
    let randomSuccess = Bool.random()
    if randomSuccess {
        success = true
        print("请求成功!")
        break
    } else if attempt >= maxAttempts {
        print("已达到最大尝试次数")
        break
    }
    
    print("请求失败，等待重试...")
    // 模拟等待时间
    Thread.sleep(forTimeInterval: 1.0)
} while attempt < maxAttempts

Swift的循环语句提供了强大而灵活的控制流能力。for-in循环擅长处理已知的序列遍历，while循环适合条件驱动的迭代，而repeat-while确保关键操作至少执行一次。通过合理选择循环结构并结合控制语句，可以编写出既高效又易读的Swift代码。

掌握这些循环技巧不仅能够提升代码质量，还能在处理复杂业务逻辑时游刃有余。在实际开发中，应根据具体需求选择最合适的循环结构，并注意性能优化和代码可读性的平衡。

函数的定义与参数传递

Swift的函数系统提供了极其灵活和强大的参数传递机制，从简单的值传递到复杂的in-out参数，每一种方式都针对特定的使用场景进行了优化。掌握这些参数传递技术是编写高效、可读性强的Swift代码的关键。

函数定义基础语法

Swift使用func关键字来定义函数，基本语法结构如下：

func 函数名(参数名: 参数类型) -> 返回类型 {
    // 函数体
    return 返回值
}

让我们通过一个简单的问候函数来理解基础定义：

func greet(person: String) -> String {
    let greeting = "Hello, " + person + "!"
    return greeting
}

print(greet(person: "Anna"))  // 输出: "

创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考