美文网首页
【Alamofire源码解析】14- Result

【Alamofire源码解析】14- Result

作者: Lebron_James | 来源:发表于2017-12-21 22:50 被阅读32次

    Result是一个泛型枚举,用于表示请求成功或者失败。如果是success,携带一个泛型Value;如果是failure,携带一个Error。

    public enum Result<Value> {
        case success(Value)
        case failure(Error)
    
        // 请求是否成功
        public var isSuccess: Bool {
            switch self {
            case .success:
                return true
            case .failure:
                return false
            }
        }
    
        // 请求是否成功
        public var isFailure: Bool {
            return !isSuccess
        }
    
        // 请求成功对应的结果
        public var value: Value? {
            switch self {
            case .success(let value):
                return value
            case .failure:
                return nil
            }
        }
    
        // 请求失败对应的error
        public var error: Error? {
            switch self {
            case .success:
                return nil
            case .failure(let error):
                return error
            }
        }
    }
    

    另外还实现了CustomStringConvertibleCustomDebugStringConvertible,方便调试。

    其他API

    // 创建一个Result,使用案例:
    //
    //     func someString() throws -> String { ... }
    //
    //     let result = Result(value: {
    //         return try someString()
    //     })
    //
    //     // result的类型是Result<String>
    //
    //     // 还可以简写成:
    //
    //     let result = Result { try someString() }
    public init(value: () throws -> Value) {
        do {
            self = try .success(value())
        } catch {
            self = .failure(error)
        }
    }
    
    // 把Result的value解压出来,使用案例:
    //
    //     let possibleString: Result<String> = .success("success")
    //     try print(possibleString.unwrap())
    //     // Prints "success"
    //
    //     let noString: Result<String> = .failure(error)
    //     try print(noString.unwrap())
    //     // Throws error
    public func unwrap() throws -> Value {
        switch self {
        case .success(let value):
            return value
        case .failure(let error):
            throw error
        }
    }
    
    // result是success的时候执行transform,使用案例:
    //
    //     let possibleData: Result<Data> = .success(Data())
    //     let possibleInt = possibleData.map { $0.count }
    //     try print(possibleInt.unwrap())
    //     // Prints "0"
    //
    //     let noData: Result<Data> = .failure(error)
    //     let noInt = noData.map { $0.count }
    //     try print(noInt.unwrap())
    //     // Throws error
    public func map<T>(_ transform: (Value) -> T) -> Result<T> {
        switch self {
        case .success(let value):
            return .success(transform(value))
        case .failure(let error):
            return .failure(error)
        }
    }
    
    // result是success的时候执行transform,使用案例:
    //
    //     let possibleData: Result<Data> = .success(Data(...))
    //     let possibleObject = possibleData.flatMap {
    //         try JSONSerialization.jsonObject(with: $0)
    //     }
    public func flatMap<T>(_ transform: (Value) throws -> T) -> Result<T> {
        switch self {
        case .success(let value):
            do {
                return try .success(transform(value))
            } catch {
                return .failure(error)
            }
        case .failure(let error):
            return .failure(error)
        }
    }
    
    // result是failure的时候执行transform,使用案例:
    //
    //     let possibleData: Result<Data> = .failure(someError)
    //     let withMyError: Result<Data> = possibleData.mapError { MyError.error($0) }
    public func mapError<T: Error>(_ transform: (Error) -> T) -> Result {
        switch self {
        case .failure(let error):
            return .failure(transform(error))
        case .success:
            return self
        }
    }
    
    // result是failure的时候执行transform,使用案例:
    //
    //     let possibleData: Result<Data> = .success(Data(...))
    //     let possibleObject = possibleData.flatMapError {
    //         try someFailableFunction(taking: $0)
    //     }
    public func flatMapError<T: Error>(_ transform: (Error) throws -> T) -> Result {
        switch self {
        case .failure(let error):
            do {
                return try .failure(transform(error))
            } catch {
                return .failure(error)
            }
        case .success:
            return self
        }
    }
    
    // 如果我们想用`请求成功的结`果来做一些操作的时候,可以用这个方法,把那些操作用closure的形式传入即可
    @discardableResult
    public func withValue(_ closure: (Value) -> Void) -> Result {
        if case let .success(value) = self { closure(value) }
    
        return self
    }
    
    // 如果我们想用`请求失败的结果`做一些操作的时候,可以用这个方法,把那些操作用closure的形式传入即可
    @discardableResult
    public func withError(_ closure: (Error) -> Void) -> Result {
        if case let .failure(error) = self { closure(error) }
    
        return self
    }
    
    // 如果我们想在`请求成功后`做一些操作的时候,可以用这个方法,把那些操作用closure的形式传入即可
    @discardableResult
    public func ifSuccess(_ closure: () -> Void) -> Result {
        if isSuccess { closure() }
    
        return self
    }
    
    // 如果我们想在`请求失败后`做一些操作的时候,可以用这个方法,把那些操作用closure的形式传入即可
    @discardableResult
    public func ifFailure(_ closure: () -> Void) -> Result {
        if isFailure { closure() }
    
        return self
    }
    

    有任何问题,欢迎大家留言!

    欢迎加入我管理的Swift开发群:536353151,本群只讨论Swift相关内容。

    原创文章,转载请注明出处。谢谢!

    相关文章

      网友评论

          本文标题:【Alamofire源码解析】14- Result

          本文链接:https://www.haomeiwen.com/subject/msmzwxtx.html