Swift 闭包详解:从语法到实战的完整指南

一、什么是闭包

闭包(Closure)是 Swift 中一种自包含的代码块,可以在代码中被传递和调用。简单来说,闭包就是一段可以捕获并存储其所在上下文中任意常量和变量引用的函数式代码块。

Swift 中的闭包与 C 和 Objective-C 中的 block 类似,也与其他编程语言中的 lambda 表达式、匿名函数概念相通。闭包可以捕获和存储其所在上下文中任意常量和变量的引用,这就是所谓的闭包捕获(capturing)。

在 Swift 中,函数实际上是闭包的一种特殊形式,全局函数和嵌套函数都是闭包:

  • 全局函数:有名字但不会捕获任何值的闭包。
  • 嵌套函数:有名字且能捕获其封闭函数内值的闭包。
  • 闭包表达式:没有名字、使用轻量级语法编写、能捕获上下文中值的闭包。

二、闭包的基本语法

Swift 闭包的标准语法格式如下:

swift 复制代码
{ (参数列表) -> 返回类型 in
    语句
}

其中 in 关键字用于分隔闭包的参数和返回类型与闭包体。下面是一个最简单的闭包示例:

swift 复制代码
let greet = { (name: String) -> String in
    return "Hello, \(name)!"
}

print(greet("Swift"))  // 输出:Hello, Swift!

闭包可以赋值给变量或常量,也可以作为参数传递给函数,或者作为函数的返回值。

三、闭包表达式的简化

Swift 为闭包提供了多种简化写法,让代码更加简洁。我们以数组的 sorted(by:) 方法为例,逐步演示简化过程。

3.1 完整写法

swift 复制代码
let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]

let sortedNames = names.sorted(by: { (s1: String, s2: String) -> Bool in
    return s1 < s2
})

3.2 省略参数和返回类型

由于 Swift 的类型推断机制,闭包的参数类型和返回类型可以省略:

swift 复制代码
let sortedNames = names.sorted(by: { s1, s2 in
    return s1 < s2
})

3.3 单表达式闭包隐式返回

如果闭包体只有一行表达式,可以省略 return 关键字:

swift 复制代码
let sortedNames = names.sorted(by: { s1, s2 in s1 < s2 })

3.4 使用简写参数名

Swift 为闭包提供了 $0、$1、$2 等简写参数名,可以省略参数列表和 in 关键字:

swift 复制代码
let sortedNames = names.sorted(by: { $0 < $1 })

3.5 使用运算符函数

由于 Swift 中的 < 运算符本身就是一个函数,可以直接传入:

swift 复制代码
let sortedNames = names.sorted(by: <)

四、尾随闭包

当闭包作为函数的最后一个参数时,可以使用**尾随闭包(Trailing Closure)**语法,将闭包写在函数调用的括号外面,提高代码可读性。

swift 复制代码
// 普通写法
let sortedNames = names.sorted(by: { $0 < $1 })

// 尾随闭包写法
let sortedNames = names.sorted { $0 < $1 }

如果闭包是函数的唯一参数,甚至可以完全省略括号:

swift 复制代码
let result = names.sorted { $0 < $1 }

当函数有多个闭包参数时,第一个闭包使用尾随闭包语法,后续闭包使用带标签的尾随闭包:

swift 复制代码
func loadData(success: () -> Void, failure: () -> Void) {
    // 实现
}

loadData {
    print("成功")
} failure: {
    print("失败")
}

五、闭包捕获值

闭包可以在其被定义的上下文中捕获常量和变量。即使定义这些常量和变量的原作用域已经不存在,闭包仍然可以在闭包函数体内引用和修改这些值。

swift 复制代码
func makeIncrementer(forIncrement amount: Int) -> () -> Int {
    var runningTotal = 0
    func incrementer() -> Int {
        runningTotal += amount
        return runningTotal
    }
    return incrementer
}

let incrementByTen = makeIncrementer(forIncrement: 10)
print(incrementByTen())  // 输出:10
print(incrementByTen())  // 输出:20
print(incrementByTen())  // 输出:30

在上面的例子中,incrementer 函数捕获了 runningTotal 和 amount 两个变量。每次调用 incrementByTen 时,runningTotal 的值都会累加。

需要注意的是,Swift 会优化闭包的捕获行为:

  • 如果闭包捕获的是值类型(如 Int、String、Struct),捕获的是值的副本。
  • 如果闭包捕获的是引用类型(如 Class 实例),捕获的是引用。

六、逃逸闭包与非逃逸闭包

6.1 非逃逸闭包

默认情况下,闭包参数是**非逃逸(Non-Escaping)**的,意味着闭包在函数返回之前就会被执行完毕,不会"逃出"函数的作用域。非逃逸闭包不会产生循环引用问题,性能也更好。

swift 复制代码
func performOperation(closure: () -> Void) {
    closure()  // 闭包在函数内部执行
}

6.2 逃逸闭包

当闭包需要在函数返回之后才被调用时,需要使用 @escaping 标记为逃逸闭包(Escaping Closure)。常见的场景包括异步回调、存储闭包属性等。

swift 复制代码
class NetworkManager {
    var completionHandler: (() -> Void)?

    func fetchData(completion: @escaping () -> Void) {
        self.completionHandler = completion
        // 模拟异步请求
        DispatchQueue.main.asyncAfter(deadline: .now() + 2) {
            completion()
        }
    }
}

逃逸闭包会延长其捕获变量的生命周期,因此需要特别注意循环引用问题。

七、自动闭包

自动闭包(Autoclosure) 是一种自动创建的闭包,用于包装传递给函数作为参数的表达式。使用 @autoclosure 标记,可以延迟表达式的求值。

swift 复制代码
func logIfTrue(_ predicate: @autoclosure () -> Bool) {
    if predicate() {
        print("条件为真")
    }
}

logIfTrue(2 > 1)  // 输出:条件为真

自动闭包常用于 assert、precondition 等断言函数,以及 ?? 运算符的实现中。需要注意的是,过度使用自动闭包会降低代码可读性。

八、循环引用与 weak/unowned

当闭包作为类的属性,并且闭包内部又引用了这个类实例时,就会形成循环引用(Retain Cycle),导致内存泄漏。

swift 复制代码
class Person {
    var name: String
    var printName: (() -> Void)?

    init(name: String) {
        self.name = name
    }

    deinit {
        print("\(name) 被释放")
    }
}

var person: Person? = Person(name: "Tom")
person?.printName = {
    print(person?.name ?? "")
}
person = nil  // 不会打印"被释放",因为存在循环引用

解决循环引用的方式是使用捕获列表(Capture List) ,配合 weak 或 unowned 关键字:

swift 复制代码
person?.printName = { [weak person] in
    print(person?.name ?? "")
}

weak 和 unowned 的区别:

关键字 是否可选 引用对象释放后 适用场景
weak 是(自动置 nil) 变为 nil 引用对象可能为 nil
unowned 否 访问会崩溃 引用对象生命周期更长

九、闭包的常见应用场景

9.1 异步回调

swift 复制代码
func fetchUserInfo(id: Int, completion: @escaping (Result<String, Error>) -> Void) {
    DispatchQueue.global().async {
        // 模拟网络请求
        let success = true
        DispatchQueue.main.async {
            if success {
                completion(.success("用户\(id)"))
            } else {
                completion(.failure(NSError(domain: "error", code: -1)))
            }
        }
    }
}

fetchUserInfo(id: 1) { result in
    switch result {
    case .success(let name):
        print("获取成功:\(name)")
    case .failure(let error):
        print("获取失败:\(error)")
    }
}

9.2 高阶函数

Swift 标准库中的 map、filter、reduce、forEach 等函数都接受闭包作为参数:

swift 复制代码
let numbers = [1, 2, 3, 4, 5]

let doubled = numbers.map { $0 * 2 }           // [2, 4, 6, 8, 10]
let evens = numbers.filter { $0 % 2 == 0 }     // [2, 4]
let sum = numbers.reduce(0) { $0 + $1 }        // 15

9.3 自定义排序

swift 复制代码
struct Student {
    let name: String
    let score: Int
}

let students = [
    Student(name: "Alice", score: 85),
    Student(name: "Bob", score: 92),
    Student(name: "Cindy", score: 78)
]

let sortedStudents = students.sorted { $0.score > $1.score }

9.4 动画与 UI 回调

swift 复制代码
UIView.animate(withDuration: 0.3) {
    self.view.alpha = 0.5
} completion: { finished in
    print("动画完成:\(finished)")
}

十、闭包与函数式编程

Swift 是一门支持函数式编程范式的语言,闭包在其中扮演着重要角色。通过闭包,我们可以实现:

  • 柯里化(Currying):将接受多个参数的函数转换为一系列接受单个参数的函数。
  • 函数组合(Function Composition):将多个小函数组合成复杂函数。
  • 惰性求值(Lazy Evaluation):通过闭包延迟计算。
swift 复制代码
// 函数组合示例
func compose<A, B, C>(_ f: @escaping (B) -> C, _ g: @escaping (A) -> B) -> (A) -> C {
    return { a in f(g(a)) }
}

let addOne = { (x: Int) in x + 1 }
let double = { (x: Int) in x * 2 }
let addThenDouble = compose(double, addOne)

print(addThenDouble(3))  // 输出:8

十一、性能与最佳实践

  • 优先使用非逃逸闭包 :非逃逸闭包性能更好,编译器可以做更多优化。只有确实需要时才使用 @escaping。
  • 注意循环引用 :在逃逸闭包中引用 self 时,务必使用 [weak self] 或 [unowned self]。
  • 避免过度简化 :虽然 $0、$1 很简洁,但当闭包逻辑复杂时,使用具名参数更易读。
  • 合理使用尾随闭包:尾随闭包能提升可读性,但多个闭包参数时要注意标签清晰。
  • 谨慎使用自动闭包:自动闭包会隐藏求值时机,过度使用会降低代码可读性。

十二、总结

闭包是 Swift 中非常强大且常用的特性,掌握闭包对于编写高质量的 Swift 代码至关重要。本文从闭包的基本概念出发,介绍了闭包的语法、简化写法、捕获机制、逃逸与非逃逸、循环引用处理以及常见应用场景。

核心要点回顾:

  1. 闭包是自包含的代码块,可以捕获上下文中的变量。
  2. Swift 提供了丰富的语法糖,让闭包写法更加简洁。
  3. 逃逸闭包需要 @escaping 标记,并注意循环引用问题。
  4. 使用 weak 或 unowned 打破循环引用。
  5. 闭包广泛应用于异步回调、高阶函数、UI 事件等场景。

建议在实际项目中多练习闭包的使用,逐步体会其设计哲学与最佳实践。

相关推荐
橙橙子2301 小时前
Linux----libevent
linux·运维·服务器
小七在进步1 小时前
string的实现(3)
开发语言·c++·笔记·visual studio
专注仿真2 小时前
基于 AFSIM 的智能体训练:多智能体强化学习篇 —— QTRAN 算法实战
开发语言·python·算法·php·强化学习·afsim智能体·仿真训练
如夏倾城2 小时前
五大远程桌面协议:RDP、SSH、VNC/RFB、Citrix ICA/HDX 与 VMware Blast Extreme
运维·windows·网络协议·安全·自动化·ssh·远程工作
无足鸟ICT3 小时前
【RHCA+】numactl命令(管理numa)
linux·运维·服务器
Funlang4 小时前
RISC-V 上的 Fun:第四套机器码
开发语言·risc-v·龙芯
feixing_fx12 小时前
第一个 JS 程序:在浏览器控制台和 Node 中分别运行
开发语言·前端·javascript·前端框架·ecmascript
Evand J13 小时前
【MATLAB例程】二维IMM-UKF定位,基于四个基站的AOA与测距辅助
开发语言·matlab
feixing_fx13 小时前
变量与声明:let、const、var 的选择边界
开发语言·前端·javascript·前端框架