概念

Swift 中的闭包是一个在上下文中闭合的独立代码块，类似于其他编程语言中的匿名函数或 Lambda 表达式。可以将 Swift 闭包看作是一个轻量级的函数实例，它可以捕获上下文中的变量和常量，并作为参数传递给其他函数。

以下是闭包的主要特点：

1. 引用类型：闭包是引用类型，像类一样，它们在分配和传递时不复制，而是传递引用。

2. 捕获上下文值：闭包可以捕获和存储定义它的上下文中的常量和变量，即使它们在闭包创建之后被修改或消失，闭包仍然可以访问它们。

3. 可被传递给函数：闭包可以通过参数的形式传递给函数，或者作为变量存储在其他闭包中以供后续调用。

闭包表达式语法

闭包的基本语法如下：

{ (parameters) -> ReturnType in
    // 闭包代码
}

这里，参数列表和返回类型可选。例如，一个没有参数和返回值的简单闭包示例：

let greet = {
    print("Hello, world!")
}

greet()

当我们需要向闭包传递参数时，可以在参数列表中定义它们：

let add = { (a: Int, b: Int) -> Int in
    return a + b
}

let sum = add(5, 7)
print(sum)  // 输出：12

将闭包作为参数传递

闭包可以像普通变量一样传递给函数。以下是一个接受简单闭包作为参数的函数：

func perform(operation: () -> Void) {
    operation()
}

perform {
    print("Performing an operation.")
}

高阶函数使用闭包

Swift 标准库中的很多函数接受闭包作为参数，例如 map, filter, reduce 和 sorted 等高阶函数。这些函数可以利用闭包提供的行为进行变换、筛选和操作集合元素。

例如，我们可以使用闭包对数组进行排序：

var numbers = [5, 2, 1, 8, 4, 7]

let sortedNumbers = numbers.sorted(by: { (a: Int, b: Int) -> Bool in
    return a < b
})

print(sortedNumbers)  // 输出：[1, 2, 4, 5, 7, 8]

在这个示例中，我们为 sorted(by:) 函数提供了一个闭包，该闭包定义了排序策略。闭包接收两个整数参数 a 和 b，返回一个布尔值，表明是否 a 应该在 b 之前出现。

闭包简写

在 Swift 中，当闭包作为参数传递给函数时，可以利用语言特性对闭包进行简写。以下列举了闭包简写的几种方法：

1. 参数类型推断：当闭包作为函数的参数时，Swift 会自动推断闭包参数的类型。因此，在闭包表达式中，无需明确指定参数类型。例如：

func doMath(_ operation: (Int, Int) -> Int) {
    let result = operation(5, 3)
    print(result)
}

doMath { a, b in
    a * b
} // 输出：15

在上述示例中，我们可以省略闭包中的参数类型 Int，因为 Swift 根据 doMath 函数类型推断出闭包参数的类型。

2. 隐式返回：针对只包含一个表达式的闭包，可以不使用 return 关键字，因为这个表达式会作为闭包的“隐式返回值”。例如：

let sortedNumbers = [5, 2, 1, 8, 4, 7].sorted { a, b in
    a < b
}

在这个示例中，我们省略了 return 关键字，因为闭包只包含一个表达式：a < b。Swift 将此表达式的结果视为隐式返回值。

3. 简写参数名：当闭包参数的名字未定义时，可以使用 $0, $1, $2 等编号引用闭包参数。例如：

let sortedNumbers = [5, 2, 1, 8, 4, 7].sorted { $0 < $1 }

在这个示例中，我们使用简写参数名 $0 和 $1 表示闭包的第一个和第二个参数。这样就不需要显式地定义参数名（例如 a, b 等）。

4. 尾随闭包（Trailing closure）：当函数的最后一个参数是一个闭包时，可以将闭包表达式移出函数括号，并跟在函数参数列表之后。这种写法在闭包表达式较长或者闭包作为主要逻辑参数时，使代码更具可读性。例如：

示例 1. 使用 map 函数

let numbers = [1, 2, 3, 4, 5]

// 使用尾随闭包语法
let squaredNumbers = numbers.map { $0 * $0 }

// 标准闭包语法
let squaredNumbersStandard = numbers.map({ $0 * $0 })

在这个示例中，使用尾随闭包语法让代码看起来更简洁。map 函数的最后一个参数是一个闭包，所以我们可以将闭包移到括号外部。

示例 2. 使用 async 函数

DispatchQueue.main.async {
    print("Hello, trailing closure!")
}

// 标准闭包语法
DispatchQueue.main.async(execute: {
    print("Hello, standard closure!")
})

在这个示例中，async 函数的最后一个参数也是一个闭包，我们将其移出参数列表，使用尾随闭包简化代码。

逃逸闭包（Escaping Closures）

逃逸闭包（escaping closure）是 Swift 中闭包的特殊类型，它指的是传递给函数的闭包会在函数返回后执行。逃逸闭包主要有以下几个特点：

使用场景

常见的逃逸闭包使用场景有：

• 异步操作，如网络请求、延时执行等。
• 存储 closure，在稍后执行。
• 将闭包传递给其他函数（闭包传递到另一个需要逃逸闭包的函数）。

在函数参数中标注

为了明确表示闭包是逃逸的，需要在参数类型前标注 @escaping 属性。这样可以在函数签名中明确表示这个闭包允许在函数返回之后执行。

func performAsync(escapingClosure: @escaping () -> Void) {
    DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
        escapingClosure()
    }
}

在这个示例中，我们使用 @escaping 标注来声明闭包 escapingClosure() 是一个逃逸闭包。

内存管理注意事项

逃逸闭包可能导致循环引用（retain cycle）问题。当闭包在函数之外执行，尤其是在闭包和类实例之间产生相互引用时，需要特别关注内存管理。这时，应使用捕获列表（capture list），指定捕获方式为 weak 或 unowned。

例如:

class Request {
    let url: String

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

    deinit {
        print("Request deinitializing.")
    }

    func getData(completion: @escaping (String) -> Void) {
        DispatchQueue.main.asyncAfter(deadline: .now() + 1) { [weak self] in
            guard let self = self else { return }
            completion(self.url)
        }
    }
}

var request: Request? = Request(url: "https://www.example.com")

request?.getData(completion: { url in
  print("Fetched data from URL: \(url)")
}) 

request = nil

在上述示例中，我们使用捕获列表 [weak self] 和 [weak request] 来避免闭包（completion 和 getData）与类（Request）之间的循环引用。

总之，在使用逃逸闭包时，需要明确其生命周期，并确保正确处理闭包在异步操作、存储和传递时可能产生的循环引用。适当地使用捕获列表能有效避免内存泄漏问题。

自动闭包（Autoclosures）

自动闭包（autoclosure）是 Swift 中一种特殊的闭包类型，它可以自动将表达式封装在一个没有参数的闭包中。当函数需要延迟求值或执行特定表达式时，可以用自动闭包将表达式传递给函数。这种类型的闭包在调用时不需要使用括号。

主要特点

1. 无参数：自动闭包是一种无参数的闭包，它从上下文中捕获值，而不是通过参数传递。
2. 延迟求值：自动闭包在调用时才执行，这意味着它们只有在显示调用时才对表达式求值。因此，可以在需要时触发表达式的执行，实现代码的延迟计算。
3. 语法简洁：自动闭包允许对实际的闭包表达式进行简化，使代码更可读和易理解。

实现自动闭包

要使用自动闭包，可以在函数参数类型前加上 @autoclosure 关键字。例如：

func assert(_ condition: @autoclosure () -> Bool, message: String) {
    if !condition() {
        print("Assert Failed: \(message)")
    } else {
        print("Assert Passed")
    }
}

这个 assert 函数接受一个条件和一条信息，如果条件求值为 true，则输出“Assert Passed”，否则输出“Assert Failed”和对应的信息。

因为 condition 参数带有 @autoclosure 标记，所以当我们调用这个函数时，只需传递一个表达式，而不需要显式地创建一个闭包。例如：

let x = 10
let y = 5

assert(x > y, message: "x should be greater than y")

在这个示例中，我们传递了表达式 x > y，而不需要将其封装为一个闭包（如 { x > y }）。@autoclosure 关键字会自动将表达式封装在一个没有参数的闭包中，在调用 condition() 时执行。

需要注意的是，由于自动闭包的延迟求值特性，可能导致一些不符合预期的情况。例如，在多线程环境中，自动闭包捕获的值在执行时可能已经发生了变化。因此，在使用自动闭包时，请注意程序的逻辑和执行顺序。

捕获列表（Capture List）

在 Swift 闭包中，捕获列表（Capture list）用于控制闭包体内的变量和常量的捕获行为。当一个闭包捕获一个实例或变量时，闭包存储了对该实例或变量的引用。捕获列表可以让你明确地指定闭包如何捕获外部的值，以避免潜在的循环引用或内存泄漏问题。

捕获列表的语法

捕获列表位于闭包参数列表和返回类型之前，用 [] 括起来，并用逗号分隔。

[weak object1, unowned object2, otherValue = someValue] (parameters) -> ReturnType in
    // 闭包体

捕获列表的种类

1. weak：将捕获的引用设为弱引用，允许引用的实例在闭包执行时被释放。当实例被释放时，弱引用变为 nil。这有助于防止引起循环引用。

2. unowned：将捕获的引用设为无主引用，表示引用的实例不会在闭包执行期间被释放。在闭包执行时，无主引用始终有值，如果你试图访问已经被释放的无主引用，会导致运行时错误。

3. 按值捕获: 可以用赋值表达式捕获变量的当前值，作为常量存储在闭包中。这样，闭包总是使用捕获时的值，而不是捕获变量最新的值。

捕获列表示例

class Person {
    var name: String
    
    init(name: String) {
        self.name = name
    }
    
    deinit {
        print("Person \(name) is being deinitialized.")
    }
}

class Task {
    var taskDescription: String
    
    lazy var completion: () -> Void = { [weak self] in
        print("Task '\(self?.taskDescription ?? "Unknown")' is completed.")
    }
    
    init(taskDescription: String) {
        self.taskDescription = taskDescription
    }
    
    deinit {
        print("Task '\(taskDescription)' is being deinitialized.")
    }
}

var person: Person? = Person(name: "John Doe")

在上面的例子中，我们使用 [weak self] 捕获列表，使得 Task 类中的 completion 闭包对 self 的引用变成弱引用，以避免循环引用。这样，当 Task 实例被释放时，闭包中的 self（即 Task 实例）将自动变为 nil。

捕获列表提供了一种显式地定义闭包捕获行为的方式，有助于防止内存泄漏和解决循环引用问题。

无主引用有什么问题

运行时错误：当试图访问一个已经被释放的无主引用时，程序会触发运行时错误。由于无主引用不会使引用计数增加，你需要确保其引用的实例在需要访问它的整个生命周期内仍然存在。如果实例被意外释放，使用无主引用会导致程序崩溃。

要依据具体情况决定是否使用无主引用。如果你知道其引用的实例在整个生命周期内一定存在，可以使用无主引用。否则，考虑将引用设为弱引用（weak），允许它在不再需要时被释放并自动变为 nil，从而避免运行时错误。在使用无主引用时，确保谨慎评估潜在的运行时风险，以防止崩溃和不稳定的应用程序行为。

闭包的使用场景

在实际应用中，闭包主要用于以下场景：

• 异步操作和回调：如网络请求和延迟执行等。
• 高阶函数：map, filter, reduce 等函数会接收闭包作为操作的参数。
• 事件处理：与用户交互、通知等事件处理相关的回调函数。
• 动画和视图转换：UIKit 和其它 UI 框架中的动画和视图转换操作。
• 资源管理和枚举：例如文件操作、GCD（Grand Central Dispatch）队列和 autoreleasepool。

注意事项

在使用闭包时，还需要关注以下几点：

• 内存管理：避免循环引用和内存泄漏。特别是在逃逸闭包和类之间互相引用时，优先选择弱引用（weak）或无主引用（unowned）。
• 简化闭包：借助 Swift 语言提供的简写特性，使闭包尽可能简化、高效。例如，使用简写参数名和省略类型等。
• 性能优化：闭包可能会带来额外的性能开销，特别是在大量创建和调用闭包的场景下。请确保在性能关键代码中谨慎使用闭包或优化闭包的实现。
• 遵循代码风格：在代码中使用闭包时，一致遵循团队或社区的编程风格和惯例，确保代码可读性。

通过掌握这些高级特性和最佳实践，可以更高效地在 Swift 项目中使用闭包。在面对问题和需求时，请根据具体应用场景和上下文选择使用闭包，确保代码质量和性能。

swift 将函数作为一等公民

Swift 中的函数是一等公民（First-class citizens），这意味着函数可以作为值使用。函数作为一等公民意味着它们可以像其他数据类型一样，被用作变量、常量、参数或返回值。以下是一个示例，说明了Swift函数作为一等公民的特性：

// 定义一个简单的Add函数
func add(x: Int, y: Int) -> Int {
    return x + y
}

// 定义一个Multiply函数
func multiply(x: Int, y: Int) -> Int {
    return x * y
}

// 将函数作为参数传递给另一个函数
func performMathOperation(operation: (Int, Int) -> Int, a: Int, b: Int) -> Int {
    return operation(a, b)
}

// 使用Add函数作为参数调用
let sumResult = performMathOperation(operation: add, a: 5, b: 3)
print(sumResult) // 输出: 8

// 使用Multiply函数作为参数调用
let multiplyResult = performMathOperation(operation: multiply, a: 5, b: 3)
print(multiplyResult) // 输出: 15

// 将函数的返回值赋值给常量
let addFunction = add
let additionResult = addFunction(5, 3)
print(additionResult) // 输出: 8

在这个示例中，我们演示了如何将函数作为值使用：

1. 将函数 add 和 multiply 作为参数传递给 performMathOperation 函数。
2. 将 add 函数作为值赋给常量 addFunction，并通过该常量调用该函数。

通过这个示例，我们可以看到 Swift 函数具有与其他数据类型相同的特性，可以在不同的上下文中自由地传递和使用。这使 Swift 的函数变得灵活且强大，有助于实现代码重用、泛型编程和高阶函数。