Swift可回溯的闭包

问题

正常情况下，对一个闭包再赋值，之前的值会被覆盖，但在某些场景下，我们需要保留旧值和新值，一般我们都会通过数组去保存，如下面代码所示，将外界传入的回调闭包保存起来，待内部的某个异步事件完成后，统一回调这样的需求场景在我们在开发中是很常见的

class Vehicle {}
enum VehicleManager {
 
    private static var loadClosures: [([Vehicle], Bool) -> Void] = [] 
    private static var isLoading = false

    static func loadList(_ completion: (([Vehicle], Bool) -> Void)? = nil) {
        if isLoading {
            loadClosures.appendIfNonNil(completion)
            return
        } 
        isLoading = true 
        loadClosures.appendIfNonNil(completion)

        AIPManger.loadVehicle { res in
            switch res {
            case .success(let models):
                onDidFetch(models, true)
            case .failure: 
                onDidFetch([], false)
            }
        }
    }

    private static func onDidFetch(_ models: [Vehicle], _ success: Bool) {
        isLoading = false
        let closures = loadClosures 
        loadClosures = [] 
        for c in closures { 
            c(models, success) 
        } 
    } 
}

可不可以在不借助任何的数据结构的情况下也能保存外部多次传入的闭包参数呢？

解决方案

以下是一种解决方案

class Vehicle {}
enum VehicleManager {
    private static var loadClosure: (([Vehicle], Bool) -> Void)?
    private static var isLoading = false

    private static func stash(_ completion: (([Vehicle], Bool) -> Void)?) {
        guard let cmp = completion else { return }
        if let oldVal = loadClosure {
            loadClosure = { arg1, arg2 in
                oldVal(arg1, arg2)
                cmp(arg1, arg2)
            }
        } else {
            loadClosure = cmp
        }
    }

    static func loadList(_ completion: (([Vehicle], Bool) -> Void)? = nil) {
        stash(completion)
        if isLoading { return }
        isLoading = true
        AIPManger.loadVehicle { res in
            isLoading = false
            let closure = loadClosure
            loadClosure = nil
            switch res {
            case .success(let models):
                closure?(models, true)
            case .failure:
                closure?([], false)
            }
        }
    }
}

仔细观察会发现stash方法是对loadClosure属性的一层包装，而这恰好是PropertyWrapper的用武之地，不太了解PropertyWrapper可以移步Swift 最佳实践之 Property Wrapper

@propertyWrapper
public struct Stash2Closure<T, U> {
    public typealias Closure = (T, U) -> Void
    private var closure: Closure?
    
    public init() {}
    
    public mutating func reset() {
        closure = nil
    }
    public mutating func callAndReset(_ arg1: T, _ arg2: U) {
        closure?(arg1, arg2)
        closure = nil
    }
    
    public var wrappedValue: Closure? {
        get { closure }
        set {
            guard let val = newValue else { return }
            if let oldVal = closure {
                closure = { arg1, arg2 in
                    oldVal(arg1, arg2)
                    val(arg1, arg2)
                }
            } else {
                closure = val
            }
        }
    }
}

使用该PropertyWrapper后的示例代码

class Vehicle {}
enum VehicleManager {
    @Stash2Closure
    private static var loadClosure: (([Vehicle], Bool) -> Void)?
    private static var isLoading = false
    static func loadList(_ completion: (([Vehicle], Bool) -> Void)? = nil) {
        loadClosure = completion
        if isLoading { return }
        isLoading = true
        AIPManger.loadVehicle { res in
            switch res {
            case .success(let models):
                _loadClosure.callAndReset(models, true)
            case .failure:
                _loadClosure.callAndReset(models, false)
            }
            isLoading = false
        }
    }
}

简洁明了了很多，后续有类似需求，一个PropertyWrapper就可以搞定。

后话

Stash2Closure属性包装器已收录在SwifterKnife当中，同时还包括只有一个参数Stash1Closure和无参数StashClosure版本的。

使用Swift开发有两年多时间，该库积累了很多在开发当中常用的方法、扩展、工具类、常见问题的通用解决方案，致力于写出更高效更符合Swift风格的代码，日常维护更新是在develop分支，会不定期合并到master分支，欢迎读者提出宝贵的意见和建议

小小Tips

若有意使用该库，建议

pod 'SwifterKnife', :git => 'https://github.com/CoderLouie/SwifterKnife.git', :branch => 'develop'