Swift4 中的 completionHandler return 字符串

Question

我正在尝试构建一个小型货币转换器，但问题是我的 completionHandler 不起作用。因此，输入的货币在函数执行后不会立即改变

我已经尝试实现一个completionHandler；然而，还没有成功

class CurrencyExchange: ViewController {

    //Outlets
    @IBOutlet weak var lblCurrency: UILabel!
    @IBOutlet weak var segOutputCurrency: UISegmentedControl!
    @IBOutlet weak var txtValue: UITextField!
    @IBOutlet weak var segInputCurrency: UISegmentedControl!


    //Variables
    var inputCurrency: String!
    var currencyCNY: Double!
    var currencyEUR: Double!
    var currencyGBP: Double!
    var currencyJPY: Double!


    override func viewDidLoad() {
        super.viewDidLoad()
        self.navigationController?.isNavigationBarHidden = true
    }


    @IBAction func btnConvert(_ sender: Any) {
        assignOutput()

        if txtValue.text == "" {
            self.lblCurrency.text = "Please insert value"
        } else {
            let inputValue = Double(txtValue.text!)!
            if segOutputCurrency.selectedSegmentIndex == 0  {
                    let output = Double(inputValue * currencyCNY!)
                    self.lblCurrency.text = "\(output)¥"
            }  else if  segOutputCurrency.selectedSegmentIndex == 1 {
                let output = Double(inputValue * currencyEUR!)
                self.lblCurrency.text = "\(output)€"
            }  else if  segOutputCurrency.selectedSegmentIndex == 2 {
                let output = Double(inputValue * currencyGBP!)
                self.lblCurrency.text = "\(output)"
            } else if  segOutputCurrency.selectedSegmentIndex == 3 {
                let output = Double(inputValue * currencyJPY!)
                self.lblCurrency.text = "\(output)"
            }
        }
    }





    func assignOutput() {

        let currencies = ["EUR", "JPY",  "CNY", "USD"]
        inputCurrency = currencies[segInputCurrency.selectedSegmentIndex]


        Alamofire.request("https://api.exchangeratesapi.io/latest?base=\(inputCurrency!)").responseJSON { (response) in
            let result = response.result
            let jsonCurrencies = JSON(result.value!)
            let dictContent = jsonCurrencies["rates"]
            self.currencyCNY = dictContent["CNY"].double
            self.currencyEUR = dictContent["EUR"].double
            self.currencyGBP = dictContent["GBP"].double
            self.currencyJPY = dictContent["JPY"].double
        }
    }   
}

预期的结果是每次调用 btnConvert 函数时都会调用 assignInput 和 assignOutput 函数并将变量设置为正确的值。我是初学者，所以非常感谢任何帮助。

Answer 1

您在 assignOutput() 中需要一个完成处理程序，我还添加了最小错误处理以避免崩溃

//Variables
var inputCurrency = ""
var currencyCNY = 0.0
var currencyEUR = 0.0
var currencyGBP = 0.0
var currencyJPY = 0.0

@IBAction func btnConvert(_ sender: Any) {
    assignOutput() { success in 
        if success {
            if txtValue.text!.isEmpty {
                self.lblCurrency.text = "Please insert value"
            } else {
                if let inputValue = Double(txtValue.text!) { 
                    if segOutputCurrency.selectedSegmentIndex == 0  {
                        let output = Double(inputValue * currencyCNY)
                        self.lblCurrency.text = "\(output)¥"
                    }  else if  segOutputCurrency.selectedSegmentIndex == 1 {
                        let output = Double(inputValue * currencyEUR)
                        self.lblCurrency.text = "\(output)€"
                    }  else if  segOutputCurrency.selectedSegmentIndex == 2 {
                        let output = Double(inputValue * currencyGBP)
                        self.lblCurrency.text = "\(output)"
                    } else if  segOutputCurrency.selectedSegmentIndex == 3 {
                        let output = Double(inputValue * currencyJPY)
                        self.lblCurrency.text = "\(output)"
                    }
                } else {
                   self.lblCurrency.text = "Please enter a number"
                }
           }
        } else {
            self.lblCurrency.text = "Could not receive the exchange rates"
        }
    }
}

func assignOutput(completion: @escaping (Bool) -> Void) {

    let currencies = ["EUR", "JPY",  "CNY", "USD"]
    inputCurrency = currencies[segInputCurrency.selectedSegmentIndex]

    Alamofire.request("https://api.exchangeratesapi.io/latest?base=\(inputCurrency)").responseJSON { (response) in
        if let result = response.result.value {
            let jsonCurrencies = JSON(result)
            let dictContent = jsonCurrencies["rates"]
            self.currencyCNY = dictContent["CNY"].double
            self.currencyEUR = dictContent["EUR"].double
            self.currencyGBP = dictContent["GBP"].double
            self.currencyJPY = dictContent["JPY"].double
            completion(true)
        } else {
            completion(false)
        }
    }
}

Answer 2

完成处理程序的基本思想是您有一些异步方法（即稍后完成的方法）并且您需要让调用者有机会提供它希望异步方法在完成时执行的操作.因此，鉴于 assignOutput 是异步方法，这就是您将使用完成处理程序转义闭包进行重构的方法。

就我个人而言，我会将此转义闭包配置为 return 一个 Result 类型：

例如：

func assignOutput(completion: @escaping (Result<[String: Double]>) -> Void) {
    let inputCurrency = ...

    Alamofire.request("https://api.exchangeratesapi.io/latest?base=\(inputCurrency)").responseJSON { response in
        switch response.result {
        case .failure(let error):
            completion(.failure(error))

        case .success(let value):
            let jsonCurrencies = JSON(value)
            guard let dictionary = jsonCurrencies["rates"].dictionaryObject as? [String: Double] else {
                completion(.failure(CurrencyExchangeError.currencyNotFound)) // this is just a custom `Error` type that I’ve defined
                return
            }

            completion(.success(dictionary))
        }
    }
}

然后你可以像这样使用它：

assignOutput { result in
    switch result {
    case .failure(let error):
        print(error)

    case .success(let dictionary):
        print(dictionary)
    }
}

通过使用 Result 类型，您有一个很好的一致模式，您可以在整个代码中检查 .failure 或 .success。

话虽如此，我建议进行各种其他改进：

我不会从另一个视图控制器 ViewController 中创建此视图控制器子 class。它应该子class UIViewController.

（从技术上讲，您可以 re-subclass 您自己的自定义视图控制器子 classes，但这非常罕见。坦率地说，当您的视图控制器子 class 你需要有 subclasses of subclasses，这可能是代码味道，表明你的视图控制器中有太多东西。）
我会给这个视图控制器起一个 class 名称，明确指示对象的类型，例如CurrencyExchangeViewController，不仅仅是 CurrencyExchange。当你开始将这些大视图控制器分解成更易于管理的东西时，这个习惯会在未来带来好处。
您在四个不同的地方有接受货币的列表：
- 在 segOutputCurrency
- 在 segInputCurrency
- 在你的 btnConvert 例程中
- 在您的 assignOutput 日常工作中
这会使您的代码变得脆弱，如果您更改货币、add/remove 货币等的顺序，则很容易出错。最好以编程方式将货币列表放在一个地方在 viewDidLoad 中更新您的 UISegmentedControl 网点，然后让您的例程都返回到允许使用的货币的单个数组。
您应该避免使用 ! 强制展开运算符。例如，如果网络请求失败，然后您引用 result.value!，您的应用程序将崩溃。您想优雅地处理发生在您控制之外的错误。
如果您要格式化货币，请记住除了货币符号之外，您还应该考虑并非所有区域都使用 . 作为小数位（例如，您的欧洲用户可能使用,)。出于这个原因，我们通常会使用 NumberFormatter 将计算出的数字转换回字符串。

下面，我只是将 NumberFormatter 用于输出，但在解释用户输入时也确实应该使用它。但我会把它留给 reader.
在处理货币时，除了货币符号之外还有一个更微妙的问题，即结果应显示多少位小数。（例如，在处理日元时，您通常没有小数位，而欧元和美元则有两位小数。）

如果需要，您可以编写自己的转换例程，但我可能会将所选货币代码与 Locale 标识符相关联，这样您就可以利用适合每种货币的符号和小数位数。我会使用 NumberFormatters.
插座名称的约定通常是一些功能名称后跟控件类型。例如。你可能有 inputTextField 或 currencyTextField 和 outputLabel 或 convertedLabel。同样，我可能会将 @IBAction 重命名为 didTapConvertButton(_:)
我个人会放弃使用 SwiftyJSON，尽管有这个名字，但我觉得它不够敏捷。我会使用 JSONDecoder.

把所有这些放在一起，你可能会得到类似这样的结果：

//  CurrencyViewController.swift

import UIKit
import Alamofire

// types used by this view controller

struct Currency {
    let code: String              // standard three character code
    let localeIdentifier: String  // a `Locale` identifier string used to determine how to format the results
}

enum CurrencyExchangeError: Error {
    case currencyNotSupplied
    case valueNotSupplied
    case currencyNotFound
    case webServiceError(String)
    case unknownNetworkError(Data?, HTTPURLResponse?)
}

struct ExchangeRateResponse: Codable {
    let error: String?
    let base: String?
    let rates: [String: Double]?
}

class CurrencyExchangeViewController: UIViewController {

    // outlets

    @IBOutlet weak var inputTextField: UITextField!
    @IBOutlet weak var inputCurrencySegmentedControl: UISegmentedControl!
    @IBOutlet weak var outputCurrencySegmentedControl: UISegmentedControl!
    @IBOutlet weak var resultLabel: UILabel!

    // private properties

    private let currencies = [
        Currency(code: "EUR", localeIdentifier: "fr_FR"),
        Currency(code: "JPY", localeIdentifier: "jp_JP"),
        Currency(code: "CNY", localeIdentifier: "ch_CH"),
        Currency(code: "USD", localeIdentifier: "en_US")
    ]

    override func viewDidLoad() {
        super.viewDidLoad()
        navigationController?.isNavigationBarHidden = true
        updateCurrencyControls()
    }

    @IBAction func didTapConvertButton(_ sender: Any) {
        let inputIndex = inputCurrencySegmentedControl.selectedSegmentIndex
        let outputIndex = outputCurrencySegmentedControl.selectedSegmentIndex

        guard inputIndex >= 0, outputIndex >= 0 else {
            resultLabel.text = errorMessage(for: CurrencyExchangeError.currencyNotSupplied)
            return
        }

        guard let text = inputTextField.text, let value = Double(text) else {
            resultLabel.text = errorMessage(for: CurrencyExchangeError.valueNotSupplied)
            return
        }

        performConversion(from: inputIndex, to: outputIndex, of: value) { result in
            switch result {
            case .failure(let error):
                self.resultLabel.text = self.errorMessage(for: error)

            case .success(let string):
                self.resultLabel.text = string
            }
        }
    }

    func updateCurrencyControls() {
        outputCurrencySegmentedControl.removeAllSegments()
        inputCurrencySegmentedControl.removeAllSegments()

        enumerateCurrencies { index, code in
            outputCurrencySegmentedControl.insertSegment(withTitle: code, at: index, animated: false)
            inputCurrencySegmentedControl.insertSegment(withTitle: code, at: index, animated: false)
        }
    }
}

// these might better belong in a presenter or view model rather than the view controller

private extension CurrencyExchangeViewController {

    func enumerateCurrencies(block: (Int, String) -> Void) {
        for (index, currency) in currencies.enumerated() {
            block(index, currency.code)
        }
    }

    func errorMessage(for error: Error) -> String {
        switch error {
        case CurrencyExchangeError.currencyNotFound:
            return NSLocalizedString("No exchange rate found for those currencies.", comment: "Error")

        case CurrencyExchangeError.unknownNetworkError:
            return NSLocalizedString("Unknown error occurred.", comment: "Error")

        case CurrencyExchangeError.currencyNotSupplied:
            return NSLocalizedString("You must indicate the desired currencies.", comment: "Error")

        case CurrencyExchangeError.valueNotSupplied:
            return NSLocalizedString("No value to convert has been supplied.", comment: "Error")

        case CurrencyExchangeError.webServiceError(let message):
            return NSLocalizedString(message, comment: "Error")

        case let error as NSError where error.domain == NSURLErrorDomain:
            return NSLocalizedString("There was a network error.", comment: "Error")

        case is DecodingError:
            return NSLocalizedString("There was a problem parsing the server response.", comment: "Error")

        default:
            return error.localizedDescription
        }
    }

    func performConversion(from fromIndex: Int, to toIndex: Int, of value: Double, completion: @escaping (Result<String?>) -> Void) {
        let originalCurrency = currencies[fromIndex]
        let outputCurrency = currencies[toIndex]

        fetchExchangeRates(for: originalCurrency.code) { result in
            switch result {
            case .failure(let error):
                completion(.failure(error))

            case .success(let exchangeRates):
                guard let exchangeRate = exchangeRates.rates?[outputCurrency.code] else {
                    completion(.failure(CurrencyExchangeError.currencyNotFound))
                    return
                }

                let outputValue = value * exchangeRate

                let locale = Locale(identifier: outputCurrency.localeIdentifier)
                let string = formatter(for: locale).string(for: outputValue)
                completion(.success(string))
            }
        }

        /// Currency formatter for specified locale.
        ///
        /// Note, this formats number using the current locale (e.g. still uses
        /// your local grouping and decimal separator), but gets the appropriate
        /// properties for the target locale's currency, namely:
        ///
        ///  - the currency symbol, and
        ///  - the number of decimal places.
        ///
        /// - Parameter locale: The `Locale` from which we'll use to get the currency-specific properties.
        /// - Returns: A `NumberFormatter` that melds the current device's number formatting and
        ///            the specified locale's currency formatting.

        func formatter(for locale: Locale) -> NumberFormatter {
            let currencyFormatter = NumberFormatter()
            currencyFormatter.numberStyle = .currency
            currencyFormatter.locale = locale

            let formatter = NumberFormatter()
            formatter.numberStyle = .currency
            formatter.currencyCode = currencyFormatter.currencyCode
            formatter.currencySymbol = currencyFormatter.currencySymbol
            formatter.internationalCurrencySymbol = currencyFormatter.internationalCurrencySymbol
            formatter.maximumFractionDigits = currencyFormatter.maximumFractionDigits
            formatter.minimumFractionDigits = currencyFormatter.minimumFractionDigits
            return formatter
        }
    }
}

// this might better belong in a network service rather than in the view controller

private extension CurrencyExchangeViewController {
    func fetchExchangeRates(for inputCurrencyCode: String, completion: @escaping (Result<ExchangeRateResponse>) -> Void) {
        Alamofire.request("https://api.exchangeratesapi.io/latest?base=\(inputCurrencyCode)").response { response in
            guard response.error == nil, let data = response.data else {
                completion(.failure(response.error ?? CurrencyExchangeError.unknownNetworkError(response.data, response.response)))
                return
            }

            do {
                let exchangeRates = try JSONDecoder().decode(ExchangeRateResponse.self, from: data)
                if let error = exchangeRates.error {
                    completion(.failure(CurrencyExchangeError.webServiceError(error)))
                } else {
                    completion(.success(exchangeRates))
                }
            } catch {
                completion(.failure(error))
            }
        }
    }
}

如上面的评论所述，我可能会将扩展中的一些内容移动到不同的对象中，但我怀疑即使是上述更改一次也有点多，所以我已经在那里停止了我的重构。

Swift4 中的 completionHandler return 字符串

completionHandler in Swift4 return String

asynchronous

completionhandler

swift