Swift 尾随闭包与捕获列表(15)

news/2025/9/25 10:16:34/文章来源:href="https://blog.51cto.com/u_12472724/14144853" target="_blank"

一、Swift 尾随闭包与捕获列表概述

Swift 作为一种现代化的编程语言，提供了丰富的函数式编程特性，其中尾随闭包和捕获列表是两个重要的概念。尾随闭包允许开发者以更简洁的语法编写闭包，而捕获列表则提供了对闭包捕获变量方式的精确控制。这两个特性在 Swift 代码中广泛使用，理解它们的原理和应用对于编写高效、安全的 Swift 代码至关重要。

本章将对 Swift 尾随闭包和捕获列表的基本概念、设计理念和应用场景进行介绍，为后续的源码分析打下基础。

二、尾随闭包的基本概念与语法

2.1 尾随闭包的定义与语法规则

尾随闭包是 Swift 中一种特殊的闭包语法，当函数的最后一个参数是闭包时，可以将闭包表达式移到函数调用括号的后面。这种语法使得代码更加简洁易读。

Swift 官方文档中对尾随闭包的语法描述如下：

func someFunctionThatTakesAClosure(closure: () -> Void) {// 函数体
}// 不使用尾随闭包的调用
someFunctionThatTakesAClosure(closure: {// 闭包体
})// 使用尾随闭包的调用
someFunctionThatTakesAClosure() {// 闭包体
}// 如果函数只接受一个闭包参数，调用时可以省略括号
someFunctionThatTakesAClosure {// 闭包体
}

2.2 尾随闭包的使用场景

尾随闭包在 Swift 代码中广泛应用于各种高阶函数和 API，例如：

数组的高阶函数：map、filter、reduce 等。
异步操作：网络请求、文件操作等的回调。
UI 动画：iOS 开发中的 UIView.animate 方法。
自定义 API：当设计接受闭包作为参数的函数时，可以使用尾随闭包语法提高 API 的可用性。

以下是一些实际使用场景的示例：

// 数组的 map 方法使用尾随闭包
let numbers = [1, 2, 3, 4]
let squared = numbers.map { $0 * $0 }// UIView.animate 方法使用尾随闭包
UIView.animate(withDuration: 0.3) {// 动画效果代码view.alpha = 0.5
} completion: { _ in// 动画完成后的回调print("Animation completed")
}// 自定义函数使用尾随闭包
func performTask(completion: () -> Void) {// 执行任务completion()
}performTask {print("Task completed")
}

2.3 尾随闭包与普通闭包的区别

尾随闭包与普通闭包的主要区别在于语法位置和可读性：

语法位置：普通闭包作为函数参数传递，而尾随闭包放在函数调用括号之后。
可读性：尾随闭包语法使代码更加流畅，特别是当闭包体较长时。
函数定义：只有当函数的最后一个参数是闭包时，才能使用尾随闭包语法。

2.4 多个闭包参数的处理

当函数接受多个闭包参数时，只有最后一个闭包可以作为尾随闭包：

func performOperation(setup: () -> Void, completion: () -> Void) {setup()// 执行操作completion()
}// 最后一个闭包可以作为尾随闭包
performOperation(setup: {print("Setting up...")
}) {print("Operation completed")
}

如果需要将多个闭包都作为尾随闭包，可以考虑重构函数设计，将多个闭包合并为一个包含多个方法的协议或结构体。

三、捕获列表的基本概念与语法

3.1 捕获列表的定义与作用

捕获列表是 Swift 中用于控制闭包如何捕获和存储外部变量的机制。通过捕获列表，可以指定闭包是强引用、弱引用还是无主引用外部变量，从而避免循环引用和内存泄漏。

捕获列表的基本语法如下：

{ [capture list] (parameters) -> return type in// 闭包体
}

3.2 捕获列表的类型

捕获列表支持三种主要的引用类型：

强引用（默认）：闭包会强引用捕获的变量，增加其引用计数。
弱引用（weak）：闭包会弱引用捕获的变量，不会增加其引用计数。当变量被释放时，弱引用会自动置为 nil（因此必须是可选类型）。
无主引用（unowned）：闭包会无主引用捕获的变量，不会增加其引用计数。与弱引用不同，无主引用假设变量在闭包使用期间始终存在，不会变为 nil。

以下是三种引用类型的示例：

class MyClass {var value = 0func createClosure() -> () -> Void {// 强引用捕获let strongClosure = {print(self.value)}// 弱引用捕获let weakClosure = { [weak self] inguard let self = self else { return }print(self.value)}// 无主引用捕获let unownedClosure = { [unowned self] inprint(self.value)}return strongClosure}
}

3.3 捕获列表的使用场景

捕获列表主要用于以下场景：

避免循环引用：当闭包和它捕获的对象之间存在循环引用时，使用弱引用或无主引用打破循环。
控制变量生命周期：当需要确保闭包不会阻止对象被释放时，使用弱引用。
处理可选值：弱引用会自动变为可选类型，需要在闭包中处理可能为 nil 的情况。
值捕获：通过捕获变量的副本而不是引用，确保闭包使用的是捕获时的值。

3.4 捕获列表与闭包参数的关系

捕获列表和闭包参数是两个独立的概念：

捕获列表：用于控制闭包如何引用外部变量。
闭包参数：用于定义闭包本身接受的参数。

两者的语法位置不同：捕获列表位于闭包参数之前，用方括号括起来。

// 捕获列表和闭包参数的示例
let closure = { [weak self] (param: Int) -> String inguard let self = self else { return "" }return "Value: \(self.value + param)"
}

四、尾随闭包的源码实现分析

4.1 尾随闭包的编译时处理

在编译时，Swift 编译器会将尾随闭包转换为普通的闭包参数。例如，以下代码：

func processItems(items: [Int], transform: (Int) -> Int) -> [Int] {return items.map(transform)
}let result = processItems(items: [1, 2, 3]) { $0 * 2 }

在编译时会被转换为：

let result = processItems(items: [1, 2, 3], transform: { $0 * 2 })

这种转换是由 Swift 编译器的前端（Swift 语法分析器）完成的，在 AST（抽象语法树）层面进行转换。

4.2 尾随闭包的运行时表示

在运行时，尾随闭包和普通闭包一样，会被表示为一个包含函数指针和捕获上下文的结构体。Swift 标准库中闭包的底层表示类似于：

struct SwiftClosure {// 函数指针，指向闭包的实现代码var functionPointer: @convention(thin) (UnsafeMutableRawPointer, ...) -> Any// 捕获上下文，存储闭包捕获的变量var captureContext: UnsafeMutableRawPointer?// 其他元数据，如引用计数等var refCount: Int
}

当函数调用时，尾随闭包会作为参数传递给函数，函数内部通过函数指针调用闭包，并通过捕获上下文访问捕获的变量。

4.3 尾随闭包的内存管理

尾随闭包的内存管理遵循 Swift 的引用计数机制：

当闭包被创建时，会分配内存存储闭包结构体和捕获上下文。
当闭包被传递或赋值时，引用计数增加。
当闭包不再被引用时，引用计数减少，当引用计数为 0 时，闭包内存被释放。

对于捕获的变量，闭包会根据捕获列表的指定方式（强引用、弱引用、无主引用）来处理：

强引用：增加被捕获变量的引用计数。
弱引用：不增加被捕获变量的引用计数，使用 WeakBox 结构体存储弱引用。
无主引用：不增加被捕获变量的引用计数，直接存储指针。

4.4 尾随闭包与函数调用的性能分析

尾随闭包的语法糖不会引入额外的性能开销，因为编译时会转换为普通的闭包参数传递。然而，闭包的捕获和调用本身会有一定的性能开销：

捕获开销：闭包捕获变量时需要分配内存存储捕获上下文。
调用开销：闭包调用涉及函数指针间接调用，比直接函数调用略慢。
内存管理开销：闭包的引用计数管理和捕获对象的生命周期管理会带来额外开销。

在大多数情况下，这些开销是可以接受的，但在性能敏感的代码中，应尽量减少不必要的闭包捕获和调用。

五、捕获列表的源码实现分析

5.1 捕获列表的编译时处理

在编译时，Swift 编译器会根据捕获列表的指定方式，生成不同的代码来处理变量的捕获：

强引用捕获：直接将变量的引用复制到捕获上下文中。
弱引用捕获：生成代码将变量的弱引用（通过 WeakBox 结构体）存储到捕获上下文中。
无主引用捕获：生成代码将变量的无主引用（直接指针）存储到捕获上下文中。

例如，以下闭包：

class MyClass {var value = 0func createClosure() -> () -> Void {return { [weak self] inguard let self = self else { return }print(self.value)}}
}

编译器会生成类似于以下的代码（伪代码）：

struct CapturedContext {var weakSelf: WeakBox<MyClass>?
}func closureImplementation(context: UnsafeMutableRawPointer) {let capturedContext = context.assumingMemoryBound(to: CapturedContext.self).pointeeguard let strongSelf = capturedContext.weakSelf?.value else { return }print(strongSelf.value)
}

5.2 捕获列表的运行时表示

在运行时，捕获列表的实现涉及以下几个关键组件：

捕获上下文：存储闭包捕获的变量。
WeakBox 结构体：用于实现弱引用，存储一个可选的对象引用，并在对象被释放时自动置为 nil。
无主引用：直接存储对象的指针，不进行自动管理。

Swift 标准库中 WeakBox 的简化实现如下：

class WeakBox<T: AnyObject> {weak var value: T?init(_ value: T) {self.value = value}
}

5.3 捕获列表的内存管理

捕获列表的内存管理机制如下：

强引用捕获：闭包会强引用捕获的变量，增加其引用计数。当闭包被释放时，对捕获变量的强引用也会被释放。
弱引用捕获：闭包使用 WeakBox 存储对变量的弱引用，不会增加变量的引用计数。当变量被释放时，WeakBox 中的引用会自动置为 nil。
无主引用捕获：闭包直接存储变量的指针，不会增加变量的引用计数。需要确保在闭包使用期间，变量不会被释放，否则会导致运行时错误。

5.4 捕获列表与循环引用的关系

捕获列表的主要用途之一是避免循环引用。循环引用通常发生在两个对象相互强引用对方时，导致两者都无法被释放。

例如，以下代码会导致循环引用：

class MyClass {var closure: (() -> Void)?init() {closure = {// 闭包强引用 self，形成循环引用print(self)}}deinit {print("Deinitialized")}
}var obj: MyClass? = MyClass()
obj = nil  // 不会触发 deinit，因为循环引用导致内存泄漏

使用弱引用捕获可以打破循环引用：

class MyClass {var closure: (() -> Void)?init() {closure = { [weak self] inguard let self = self else { return }print(self)}}deinit {print("Deinitialized")}
}var obj: MyClass? = MyClass()
obj = nil  // 会触发 deinit，内存正常释放

六、尾随闭包与捕获列表的组合应用

6.1 组合使用的常见场景

尾随闭包和捕获列表经常组合使用，特别是在处理异步操作和避免循环引用的场景中。例如：

网络请求回调：使用尾随闭包提供回调，同时使用捕获列表避免循环引用。
定时器回调：使用尾随闭包定义定时执行的代码，使用捕获列表确保定时器能被正确释放。
动画完成回调：使用尾随闭包处理动画完成后的操作，使用捕获列表避免循环引用。

以下是一个网络请求的示例：

class NetworkManager {var task: URLSessionDataTask?func fetchData(completion: @escaping (Data?, Error?) -> Void) {guard let url = URL(string: "https://example.com/api/data") else {completion(nil, NSError(domain: "Invalid URL", code: 0, userInfo: nil))return}task = URLSession.shared.dataTask(with: url) { [weak self] data, response, error in// 处理响应completion(data, error)// 确保任务完成后释放自身引用self?.task = nil}task?.resume()}
}

6.2 组合使用的语法规则

当尾随闭包和捕获列表组合使用时，语法规则如下：

捕获列表位于闭包参数列表之前，用方括号括起来。
尾随闭包的位置仍然在函数调用括号之后。

例如：

func performTask(completion: @escaping () -> Void) {// 执行任务completion()
}performTask { [weak self] inguard let self = self else { return }// 使用 self 安全地执行操作
}

6.3 组合使用的性能考虑

组合使用尾随闭包和捕获列表时，需要考虑以下性能因素：

捕获开销：捕获列表中的每个变量都会增加闭包的内存占用和初始化时间。
弱引用解包开销：使用弱引用捕获时，每次访问弱引用都需要检查是否为 nil，这会增加一些开销。
闭包生命周期：捕获列表会影响闭包和被捕获对象的生命周期，不当的使用可能导致内存泄漏或对象过早释放。

在性能敏感的代码中，应尽量减少捕获的变量数量，避免不必要的弱引用解包，并确保闭包在不再需要时及时释放。

6.4 组合使用的最佳实践

组合使用尾随闭包和捕获列表时，建议遵循以下最佳实践：

避免不必要的捕获：只捕获闭包真正需要的变量。
优先使用弱引用：当闭包和捕获对象之间可能存在循环引用时，优先使用弱引用。
及时释放强引用：如果必须使用强引用，确保在适当的时候释放引用，避免内存泄漏。
明确闭包的生命周期：理解闭包的生命周期和它对捕获对象的影响，确保对象在闭包使用期间不会被意外释放。
使用 guard let 解包弱引用：在闭包内部使用 guard let 解包弱引用，提高代码的安全性和可读性。

七、尾随闭包与捕获列表的高级应用

7.1 捕获列表中的值捕获

通常情况下，闭包捕获的是变量的引用，但可以通过捕获列表实现值捕获：

func createClosures() -> [() -> Int] {var closures = [() -> Int]()for i in 0..<3 {closures.append { [i] in  // 值捕获 ireturn i}}return closures
}let closures = createClosures()
print(closures[0]())  // 输出 0
print(closures[1]())  // 输出 1
print(closures[2]())  // 输出 2

在这个例子中，闭包捕获的是 i 的值而不是引用，因此每个闭包都保存了捕获时 i 的值。

7.2 捕获列表中的重命名

捕获列表允许对捕获的变量进行重命名，提高代码的可读性：

class MyClass {var value = 0func createClosure() -> () -> Void {return { [weak self as weakSelf] inguard let strongSelf = weakSelf else { return }print(strongSelf.value)}}
}

在这个例子中，self 被重命名为 weakSelf，使闭包内部的代码更清晰。

7.3 捕获列表与泛型的结合

捕获列表可以与泛型一起使用，处理泛型类型的捕获：

func makeGenericClosure<T>(value: T) -> () -> T {return { [value] inreturn value}
}let intClosure = makeGenericClosure(value: 42)
print(intClosure())  // 输出 42let stringClosure = makeGenericClosure(value: "Hello")
print(stringClosure())  // 输出 "Hello"

7.4 捕获列表与异步编程

在异步编程中，捕获列表特别有用，可以避免循环引用和处理对象生命周期：

class ViewController: UIViewController {func loadData() {APIClient.shared.fetchData { [weak self] result inguard let self = self else { return }switch result {case .success(let data):self.processData(data)case .failure(let error):self.showError(error)}}}// 其他方法省略...
}

在这个例子中，闭包使用弱引用捕获 self，避免了 ViewController 和网络请求之间的循环引用。

八、尾随闭包与捕获列表的性能优化

8.1 减少不必要的捕获

闭包捕获变量会增加内存占用和初始化时间，因此应尽量减少不必要的捕获：

// 不好的做法：捕获了不需要的变量
func processItems(items: [Int]) {let multiplier = 2items.forEach { [multiplier, self] item in  // 不需要捕获 selfprint(item * multiplier)}
}// 好的做法：只捕获必要的变量
func processItems(items: [Int]) {let multiplier = 2items.forEach { [multiplier] item inprint(item * multiplier)}
}

8.2 优化弱引用解包

频繁解包弱引用会带来性能开销，可以在闭包开始时一次性解包：

// 不好的做法：多次解包弱引用
func fetchData() {APIClient.shared.fetchData { [weak self] result inself?.processResult(result)self?.updateUI()}
}// 好的做法：一次性解包弱引用
func fetchData() {APIClient.shared.fetchData { [weak self] result inguard let self = self else { return }self.processResult(result)self.updateUI()}
}

8.3 使用无主引用代替弱引用

在确保对象不会在闭包之前被释放的情况下，使用无主引用可以避免弱引用的可选性检查：

// 使用弱引用
func setupTimer() {timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ inguard let self = self else { return }self.updateTimer()}
}// 使用无主引用（确保 timer 在 self 之后释放）
func setupTimer() {timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [unowned self] _ inself.updateTimer()}
}

8.4 避免在高性能代码中使用闭包

在性能关键的代码中，应尽量避免使用闭包，因为闭包的捕获和调用会带来额外开销：

// 性能敏感的循环
func calculateSum(items: [Int]) -> Int {var sum = 0// 直接循环比使用闭包更快for item in items {sum += item}return sum
}

九、尾随闭包与捕获列表的常见问题与解决方案

9.1 循环引用问题

循环引用是使用闭包时最常见的问题，通常发生在闭包强引用捕获对象，而对象又强引用闭包时。

解决方案：

使用弱引用（[weak self]）或无主引用（[unowned self]）捕获对象。
在适当的时候释放闭包引用，例如在对象的 deinit 方法中。

9.2 捕获变量的值不符合预期

有时闭包捕获的变量值可能不符合预期，特别是在循环中捕获变量时。

解决方案：

使用值捕获确保闭包捕获的是变量的副本：[variable] in。
在循环内部创建临时变量存储当前值：

for item in items {let temp = itemclosures.append { [temp] inprint(temp)}
}

9.3 弱引用解包导致的代码冗余

频繁解包弱引用会导致代码冗余，降低可读性。

解决方案：

在闭包开始时一次性解包弱引用：guard let self = self else { return }。
使用无主引用（如果确保对象不会提前释放）。

9.4 闭包导致的内存泄漏

如果闭包持有对对象的强引用，而对象又无法释放闭包，会导致内存泄漏。

解决方案：

使用弱引用或无主引用捕获对象。
在适当的时候释放闭包引用，例如在视图控制器的 viewDidDisappear 方法中。

十、尾随闭包与捕获列表的设计模式与最佳实践

10.1 回调模式

回调模式是尾随闭包最常见的应用之一，用于异步操作完成后通知调用者：

func performAsyncTask(completion: @escaping (Result<Data, Error>) -> Void) {// 执行异步任务DispatchQueue.global().async {// 模拟网络请求sleep(2)if let data = "Hello, World!".data(using: .utf8) {completion(.success(data))} else {completion(.failure(NSError(domain: "Data error", code: 1, userInfo: nil)))}}
}// 使用尾随闭包调用
performAsyncTask { result inswitch result {case .success(let data):print("Received data: \(String(data: data, encoding: .utf8) ?? "")")case .failure(let error):print("Error: \(error)")}
}

10.2 构建器模式

尾随闭包可以用于实现构建器模式，使 API 更加流畅：

class ViewBuilder {private var view = UIView()func withBackgroundColor(_ color: UIColor) -> Self {view.backgroundColor = colorreturn self}func withFrame(_ frame: CGRect) -> Self {view.frame = framereturn self}func build() -> UIView {return view}
}// 使用尾随闭包配置
let view = ViewBuilder().withBackgroundColor(.red).withFrame(CGRect(x: 0, y: 0, width: 100, height: 100)).build()

10.3 观察者模式

捕获列表可以用于实现观察者模式，避免循环引用：

class NotificationCenter {private var observers = [WeakBox<AnyObject>]()func addObserver(_ observer: AnyObject) {observers.append(WeakBox(observer))}func postNotification() {for box in observers {if let observer = box.value {// 通知观察者(observer as? NotificationObserver)?.handleNotification()}}}
}protocol NotificationObserver: AnyObject {func handleNotification()
}

10.4 资源管理模式

捕获列表可以用于实现资源管理模式，确保资源在适当的时候被释放：

func withFile(_ filePath: String, handler: (FileHandle) -> Void) {let fileHandle = FileHandle(forReadingAtPath: filePath)!defer {fileHandle.closeFile()}handler(fileHandle)
}// 使用尾随闭包处理文件
withFile("/path/to/file.txt") { fileHandle inlet data = fileHandle.readDataToEndOfFile()print("Read \(data.count) bytes")
}

十一、尾随闭包与捕获列表的未来发展趋势

11.1 与新语言特性的集成

随着 Swift 语言的发展，尾随闭包和捕获列表可能会与新特性更紧密地集成，例如：

宏（Macros）：可能会有宏来自动生成捕获列表，减少样板代码。
改进的生命周期管理：未来的 Swift 版本可能会提供更强大的生命周期管理工具，进一步简化捕获列表的使用。
更安全的无主引用：可能会引入更安全的无主引用机制，减少运行时错误的风险。

11.2 性能优化的持续改进

Swift 团队可能会继续优化闭包和捕获列表的性能，例如：

更高效的捕获上下文：改进捕获上下文的内存布局和访问方式。
减少闭包调用开销：优化闭包调用的底层实现，减少间接调用的开销。
更好的编译器优化：提高编译器对闭包和捕获列表的分析能力，生成更高效的代码。

11.3 语法糖的扩展

未来可能会引入更多的语法糖来简化尾随闭包和捕获列表的使用，例如：

更简洁的捕获列表语法：可能会引入更简洁的语法来表达常见的捕获模式。
自动弱引用捕获：在某些情况下，编译器可能会自动插入弱引用捕获，减少手动编写的工作量。

11.4 与其他编程范式的融合

尾随闭包和捕获列表可能会与其他编程范式更紧密地融合，例如：

并发编程：在 Swift 的并发模型中，闭包和捕获列表将继续发挥重要作用，可能会有专门的语法或库来简化并发场景下的使用。
函数式编程：随着 Swift 对函数式编程支持的增强，闭包和捕获列表的功能可能会进一步扩展。

十二、尾随闭包与捕获列表的实战案例分析

12.1 iOS 开发中的网络请求

在 iOS 开发中，网络请求通常使用尾随闭包处理回调：

class APIClient {func fetchData(from url: URL, completion: @escaping (Result<Data, Error>) -> Void) {let task = URLSession.shared.dataTask(with: url) { [weak self] data, response, error inguard let self = self else { return }if let error = error {completion(.failure(error))return}guard let data = data else {completion(.failure(NSError(domain: "No data received", code: 0, userInfo: nil)))return}completion(.success(data))}task.resume()}
}// 使用尾随闭包调用
let client = APIClient()
client.fetchData(from: URL(string: "https://example.com/api/data")!) { result inswitch result {case .success(let data):// 处理数据breakcase .failure(let error):// 处理错误break}
}

12.2 UI 动画与过渡效果

UI 动画通常使用尾随闭包定义动画效果和完成回调：

class ViewController: UIViewController {let animatedView = UIView()override func viewDidLoad() {super.viewDidLoad()// 设置动画视图animatedView.frame = CGRect(x: 50, y: 50, width: 100, height: 100)animatedView.backgroundColor = .redview.addSubview(animatedView)}func animateView() {UIView.animate(withDuration: 0.5, delay: 0, options: .curveEaseInOut) { [weak self] inguard let self = self else { return }self.animatedView.frame.origin.x += 200} completion: { [weak self] _ inguard let self = self else { return }// 动画完成后执行的操作self.animatedView.backgroundColor = .blue// 可以链式调用另一个动画UIView.animate(withDuration: 0.3) {self.animatedView.alpha = 0.5}}}
}

12.3 响应式编程与 Combine

在使用 Combine 进行响应式编程时，尾随闭包经常用于处理订阅事件：

import Combineclass ViewModel {private var subscriptions = Set<AnyCancellable>()func fetchData() {let url = URL(string: "https://example.com/api/data")!URLSession.shared.dataTaskPublisher(for: url).map(\.data).decode(type: [Item].self, decoder: JSONDecoder()).receive(on: DispatchQueue.main).sink { [weak self] completion inguard let self = self else { return }switch completion {case .finished:print("Fetch completed")case .failure(let error):self.handleError(error)}} receiveValue: { [weak self] items inguard let self = self else { return }self.processItems(items)}.store(in: &subscriptions)}// 其他方法省略...
}

12.4 自定义框架与库的设计

在设计自定义框架和库时，使用尾随闭包和捕获列表可以提供简洁、安全的 API：

// 自定义网络请求库
public class NetworkClient {public static let shared = NetworkClient()private init() {}@discardableResultpublic func request<T: Decodable>(_ endpoint: Endpoint,completion: @escaping (Result<T, Error>) -> Void) -> URLSessionDataTask {let request = endpoint.makeURLRequest()let task = URLSession.shared.dataTask(with: request) { [weak self] data, response, error inguard let self = self else { return }if let error = error {completion(.failure(error))return}guard let data = data else {completion(.failure(NetworkError.noData))return}do {let decoder = JSONDecoder()decoder.dateDecodingStrategy = .iso8601let result = await decoder.decode(T.self, from: data)completion(.success(result))} catch {completion(.failure(error))}}task.resume()return task}
}// 使用自定义库
NetworkClient.shared.request(.fetchUsers) { [weak self] (result: Result<[User], Error>) inguard let self = self else { return }switch result {case .success(let users):self.updateUI(with: users)case .failure(let error):self.showError(error)}
}