Swift中同步异步重载函数重复逻辑的简化实现方案咨询

Swift本身没有原生语法糖能直接生成一个函数的同步/异步双版本，但可以通过几种实用模式大幅减少重复代码，甚至在多异步调用场景下也能高效复用逻辑：

1. 核心思路：分离可变操作与不变逻辑 #

最直接的方式是把两个函数中完全相同的业务处理逻辑抽离成独立的私有函数，只在同步/异步入口函数中处理差异的IO操作（同步读/异步读）。

比如针对你的示例，改造后代码如下：

class Api {
    func readFile() async -> String {
        let result = await fs.readAsync()
        return processFileContent(result)
    }
    
    func readFile() -> String {
        let result = fs.read()
        return processFileContent(result)
    }
    
    // 抽离所有重复的业务逻辑到这里
    private func processFileContent(_ content: String) -> String {
        // ... 原来的// ... body逻辑
        return processedContent
    }
}

多异步调用场景的处理 #

如果函数内部有多个异步/同步操作串联，同样可以把每个步骤的业务处理逻辑抽离，只在入口函数中维护操作的调用顺序：

class Api {
    func readFile() async -> String {
        let rawContent = await fs.readAsync()
        let validatedContent = validateContent(rawContent)
        let formattedContent = await fs.formatAsync(validatedContent)
        return finalizeContent(formattedContent)
    }
    
    func readFile() -> String {
        let rawContent = fs.read()
        let validatedContent = validateContent(rawContent)
        let formattedContent = fs.format(validatedContent)
        return finalizeContent(formattedContent)
    }
    
    // 抽离各步骤的公共逻辑
    private func validateContent(_ content: String) -> String { /*...*/ }
    private func finalizeContent(_ content: String) -> String { /*...*/ }
}

2. 协议抽象：统一同步/异步操作接口 #

如果你的同步/异步IO操作有一套固定的流程，可以用协议抽象IO操作的行为，然后让同步/异步实现分别遵循协议，最后在公共逻辑中依赖协议类型：

// 定义同步IO操作协议
protocol SyncFileHandler {
    func read() -> String
    func format(_ content: String) -> String
}

// 定义异步IO操作协议
protocol AsyncFileHandler {
    func readAsync() async -> String
    func formatAsync(_ content: String) async -> String
}

class Api {
    private let syncHandler: SyncFileHandler
    private let asyncHandler: AsyncFileHandler
    
    init(syncHandler: SyncFileHandler, asyncHandler: AsyncFileHandler) {
        self.syncHandler = syncHandler
        self.asyncHandler = asyncHandler
    }
    
    func readFile() -> String {
        return processFile(with: syncHandler)
    }
    
    func readFile() async -> String {
        return await processFile(with: asyncHandler)
    }
    
    // 同步流程的公共逻辑
    private func processFile(with handler: SyncFileHandler) -> String {
        let raw = handler.read()
        let validated = validateContent(raw)
        let formatted = handler.format(validated)
        return finalizeContent(formatted)
    }
    
    // 异步流程的公共逻辑
    private func processFile(with handler: AsyncFileHandler) async -> String {
        let raw = await handler.readAsync()
        let validated = validateContent(raw)
        let formatted = await handler.formatAsync(validated)
        return finalizeContent(formatted)
    }
    
    private func validateContent(_ content: String) -> String { /*...*/ }
    private func finalizeContent(_ content: String) -> String { /*...*/ }
}

这种方式适合IO操作逻辑复杂、需要多处复用同步/异步流程的场景，能最大程度降低后续修改的成本。

3. 同步转异步的临时方案（不推荐原生异步场景使用） #

如果你只有同步IO函数，想快速得到异步版本，可以用withCheckedContinuation包装，但这本质是把同步操作放到异步队列执行，不会真正提升性能，反而可能占用线程资源。仅适合没有原生异步API的场景：

func readFile() async -> String {
    return await withCheckedContinuation { continuation in
        let result = fs.read()
        continuation.resume(returning: processFileContent(result))
    }
}

总结 #

不管是单步还是多步操作，核心都是让业务处理逻辑只关注数据本身，不关心数据的获取是同步还是异步，通过抽离、协议抽象等方式，将差异点隔离在入口函数中，就能避免重复代码，降低维护成本。

内容的提问来源于stack exchange，提问作者Stopee