Swift 函数：从基础到实战的完整指南
在 Swift 语言中，函数是构建程序逻辑的核心单元。你可以把函数想象成一个“工具箱”——它接收输入，执行特定任务，然后返回结果。无论是计算两个数的和，还是处理用户输入的数据，函数都能让代码更清晰、更可复用。对于初学者来说，掌握 Swift 函数是迈向专业开发的第一步；对中级开发者而言，深入理解函数的高级特性，能显著提升代码的可维护性和表达力。
Swift 函数的设计理念是简洁而强大，它不仅支持传统的函数定义方式，还融合了现代编程语言的诸多优势，比如闭包、默认参数、可变参数等。本文将带你系统性地学习 Swift 函数的方方面面，从最基础的语法开始，逐步深入到实际项目中的应用。
函数的基本语法与定义
在 Swift 中，函数使用 func 关键字定义，其基本结构如下：
func 函数名(参数列表) -> 返回类型 {
// 函数体
// 执行逻辑
return 返回值
}
让我们通过一个简单的例子来理解：
func greet(name: String) -> String {
// 接收一个字符串参数 name，表示用户姓名
// 返回一个问候语字符串
return "你好，\(name)！欢迎来到 Swift 世界。"
}
// 调用函数
let message = greet(name: "小明")
print(message) // 输出：你好，小明！欢迎来到 Swift 世界。
这里的关键点是：
func是函数定义的起始关键字；name: String表示函数接收一个名为name的参数，类型为String；-> String定义了函数的返回值类型，这里是String；- 函数体内使用
return返回结果； - 调用时必须提供参数名称（如
name: "小明"），这是 Swift 的命名参数特性，让调用更清晰。
提示：命名参数是 Swift 的一大亮点，它让函数调用像自然语言一样可读。比如
greet(name: "小明")比greet("小明")更直观。
参数类型与默认值
函数的参数不仅可以指定类型，还可以设置默认值，这大大增强了函数的灵活性。
func calculateTax(income: Double, taxRate: Double = 0.15) -> Double {
// income：收入金额，单位元
// taxRate：税率，默认为 15%（即 0.15）
// 返回应缴税款
return income * taxRate
}
// 使用默认税率
let tax1 = calculateTax(income: 10000)
print(tax1) // 输出：1500.0
// 自定义税率
let tax2 = calculateTax(income: 10000, taxRate: 0.2)
print(tax2) // 输出：2000.0
这个例子中，taxRate: Double = 0.15 表示参数 taxRate 有默认值。当调用函数时没有传入 taxRate，系统会自动使用默认值。
小贴士：默认参数必须放在参数列表的末尾，否则编译器会报错。这是为了避免调用时参数歧义。
可变参数与外部参数名
有时候你需要处理不确定数量的输入值，Swift 提供了可变参数（variadic parameters）来解决这个问题。
func calculateAverage(_ numbers: Double...) -> Double {
// _ 表示不使用外部参数名，内部使用 numbers
// Double... 表示接收任意数量的 Double 类型参数
guard !numbers.isEmpty else { return 0.0 }
let sum = numbers.reduce(0, +)
return sum / Double(numbers.count)
}
// 调用示例
let avg1 = calculateAverage(1.0, 2.0, 3.0)
print(avg1) // 输出：2.0
let avg2 = calculateAverage(10.5, 20.3, 30.2, 40.0)
print(avg2) // 输出：25.25
Double... 是可变参数语法，它允许函数接收零个或多个 Double 值。函数内部通过 numbers 数组访问这些值。
此外，你还可以为参数设置外部参数名，让调用更清晰：
func introduce(person: String, from location: String) {
print("我是 \(person)，来自 \(location)。")
}
introduce(person: "李华", from: "北京") // 外部名让调用更易读
如果不想写外部名，可以用下划线 _ 代替：
func add(_ a: Int, _ b: Int) -> Int {
return a + b
}
let result = add(5, 3) // 调用时无需写参数名
函数作为第一类类型
Swift 中的函数不仅是代码块，它还是“第一类值”（first-class value），这意味着函数可以被赋值给变量、作为参数传递、甚至作为返回值。
// 定义一个函数类型：接收两个 Int，返回一个 Int
typealias MathOperation = (Int, Int) -> Int
// 将函数赋值给变量
let add: MathOperation = { (a, b) in
return a + b
}
let multiply: MathOperation = { (a, b) in
return a * b
}
// 用变量调用函数
let sum = add(4, 5)
let product = multiply(3, 6)
print("加法结果：\(sum)") // 输出：加法结果：9
print("乘法结果：\(product)") // 输出：乘法结果：18
这个特性在高阶函数中尤为重要。例如，你可以将函数作为参数传入另一个函数：
func performOperation(_ a: Int, _ b: Int, operation: MathOperation) -> Int {
// operation 是一个函数，接收两个 Int，返回 Int
return operation(a, b)
}
let result = performOperation(8, 2, operation: add)
print(result) // 输出：10
这种“函数传函数”的模式，是函数式编程的核心思想之一。
嵌套函数与闭包
Swift 支持在函数内部定义函数，称为嵌套函数（nested function）。它们可以访问外部函数的变量，形成闭包（closure）。
func makeIncrementer(incrementAmount: Int) -> () -> Int {
// 外部函数接收一个增量值
// 返回一个内部函数，该函数每次调用都会增加一个值
var currentValue = 0
// 嵌套函数，可以访问外部变量 currentValue 和 incrementAmount
func increment() -> Int {
currentValue += incrementAmount
return currentValue
}
// 返回嵌套函数本身（不加括号）
return increment
}
// 创建两个不同的增量器
let addTwo = makeIncrementer(incrementAmount: 2)
let addFive = makeIncrementer(incrementAmount: 5)
print(addTwo()) // 输出：2
print(addTwo()) // 输出：4
print(addFive()) // 输出：5
print(addTwo()) // 输出：6
这里的关键是：increment 函数虽然定义在 makeIncrementer 内部，但它“捕获”了外部变量 currentValue 和 incrementAmount，形成了闭包。即使 makeIncrementer 执行完毕，addTwo 和 addFive 依然能记住它们的初始状态。
实战案例：构建一个简单的计算器
让我们用所学知识，构建一个简单的计算器函数，支持加减乘除操作。
enum Operation {
case add, subtract, multiply, divide
}
func calculate(_ a: Double, _ b: Double, operation: Operation) -> Double? {
// 根据操作类型执行计算
// 返回 Optional<Double>，避免除零错误
switch operation {
case .add:
return a + b
case .subtract:
return a - b
case .multiply:
return a * b
case .divide:
if b == 0 {
print("错误：除数不能为零")
return nil // 除零时返回 nil
}
return a / b
}
}
// 使用示例
if let result1 = calculate(10, 5, operation: .add) {
print("10 + 5 = \(result1)") // 输出：10 + 5 = 15.0
}
if let result2 = calculate(10, 0, operation: .divide) {
print("10 / 0 = \(result2)")
} else {
print("计算失败，除数为零") // 输出：计算失败，除数为零
}
这个例子展示了：
- 使用
enum定义操作类型； - 使用
Optional处理潜在错误； - 函数返回
Double?类型，增强安全性； - 通过
switch实现多分支逻辑。
总结与进阶建议
通过本文的学习，你已经掌握了 Swift 函数的核心语法与实用技巧：从基础定义到可变参数、默认值，再到函数作为值类型、闭包与嵌套函数，每一步都为你构建更健壮、更优雅的代码打下基础。
Swift 函数不仅是代码复用的工具，更是表达逻辑、提高可读性的关键。当你在项目中频繁使用函数时，你会发现代码结构更清晰、维护成本更低。
建议初学者从写简单函数开始，逐步尝试将复杂逻辑封装成函数；中级开发者可深入研究闭包、高阶函数和函数式编程模式，进一步提升代码质量。
记住，好的函数应该“单一职责”：一个函数只做一件事。这不仅是编程规范，更是对代码可读性和可维护性的尊重。
在接下来的学习中，不妨尝试将你项目中的重复代码提取为函数，体验 Swift 函数带来的便利与力量。