Question

我想终止操作并隐藏键盘，以便用户在按下计算按钮多次时可以获得相同的结果。我的代码如下：

import UIKit

class ViewController: UIViewController {

    @IBOutlet weak var textField: UITextField!

    @IBOutlet weak var result: UILabel!
    var myArray = [Int]() // empty array of int

    func convert(a:Character) -> Int {
        if (a == "1") {
           return 1;
        }
        else {
            return 0;
        }            
    }

    func power(a:Int , b:Int) -> Int {
        var result = 1
        for var i = 0; i < b; i++ {
            result *= a
        }
        return result
    }

    @IBAction func binaryNumber(sender: AnyObject) {
        var text = textField.text.toInt() // for checking whether or not user left the textfield empty
        if text != nil {            
            for  i in textField.text {
                myArray += [convert(i)]                
            }

            var exponent =  myArray.count - 1;

            //Multiplying binary number with power of 2
            for var i = 0; i < myArray.count; i++ {
                var base = 2;
                myArray[i] = myArray[i] * power(base, b: exponent)
                exponent--
            }

            // add up
            var sum = 0
            for var i = 0; i < myArray.count; i++ {
                sum += myArray[i]
            }

            result.text = "\(sum)"
        }
        else {
          result.text = "Please enter binary number"
        }            
    }

    override func touchesBegan(touches: Set<NSObject>, withEvent event: UIEvent) {            
        self.view.endEditing(true)
    }
}

Answer 1

在我原来的答案中（在这个问题的最后），我回答了一个更为复杂的问题，即如何终止耗时的计算。

但是，正如苏丹指出的那样，你可能会问一个更简单的问题，即如何重置计算，这样当你第二次计算它时，你会得到相同的结果。

问题的根源在于您已将myArray定义为属性（在调用binaryNumber之间保持不变），而它应该是binaryNumber内的局部变量。< / p>

例如：

// do not define `myArray` here:
//
// var myArray = [Int]()

@IBAction func binaryNumber(sender: AnyObject) {

    // instead, define it here:

    var myArray = [Int]()

    // now the rest of your method continues as before 

    var text = textField.text.toInt() // for checking whether or not user left the textfield empty
    if text != nil {            
        for  i in textField.text {
            myArray += [convert(i)]                
        }

        var exponent =  myArray.count - 1;

        //Multiplying binary number with power of 2
        for var i = 0; i < myArray.count; i++ {
            var base = 2;
            myArray[i] = myArray[i] * power(base, b: exponent)
            exponent--
        }

        // add up
        var sum = 0
        for var i = 0; i < myArray.count; i++ {
            sum += myArray[i]
        }

        result.text = "\(sum)"
    }
    else {
      result.text = "Please enter binary number"
    }            
}

或者，您可以将myArray作为属性，但随后更改binaryNumber以手动重置它：

@IBAction func binaryNumber(sender: AnyObject) {
    myArray = [Int]()

    // the rest of your method here
}

就个人而言，我更喜欢前一种方法（使myArray成为局部变量;它可以解决问题并避免意外后果），但任何一种方法都可以解决您的问题。

BTW，我的原始答案，讨论如何取消长时间运行的操作，如下所示。

-

有几点想法：

如果要取消操作，请添加一个布尔属性，指示是否取消该操作，并在计算循环中检查该变量的状态，以确定是否中止计算。
但是，要实现此功能，您必须在后台线程中进行此计算。因此后台线程将进行计算，主线程将处理UI以及启动/取消计算操作。

优雅的模式是将计算包装在NSOperation子类中，该子类具有现有的cancelled属性，您可以检查并确定是否要取消该操作。

因此，将计算包装在NSOperation：

中

class CalculationOperation : NSOperation {

    var inputString: String
    var completionHandler: (Int)->()

    init(string: String, completion: (Int)->()) {
        inputString = string
        self.completionHandler = completion

        super.init()
    }

    func convert(character: Character) -> Int {
        if character == "1" {
            return 1
        } else {
            return 0
        }
    }

    override func main() {
        // get the array of numeric values for the characters

        let digitValues = inputString.characters.map { convert($0) }

        // convert to binary

        var sum = 0
        var exponent = digitValues.count - 1;

        for var i = 0; i < digitValues.count; i++ {
            if cancelled { return }            // check to see if the user canceled the operation, and if so, quit

            let digit = digitValues[i]
            let value = digit * 1 << exponent  // using bitwise shift is more efficient than `power`
            sum += value
            exponent--
        }

        dispatch_async(dispatch_get_main_queue()) {
            self.completionHandler(sum)
        }
    }
}

然后您的IBAction可以将此操作添加到NSOperationQueue以便在后台执行操作，首先取消该队列上的任何其他操作：

lazy var queue = NSOperationQueue()

@IBAction func binaryNumber(sender: AnyObject) {
    textField.endEditing(true)

    queue.cancelAllOperations()

    let operation = CalculationOperation(string: textField.text!) { result in
        self.resultLabel.text = "\(result)"
    }
    queue.addOperation(operation)
}

顺便说一下，使用函数式编程可以提高上述NSOperation子类中的二进制转换例程：
```
override func main() {
    let digitValues = inputString.characters.map { convert($0) }
    let binaryValue = digitValues.reduce(0) { $0 << 1 + $1 }

    dispatch_async(dispatch_get_main_queue()) {
        self.completionHandler(binaryValue)
    }
}
```
请注意，map和reduce的这些功能方法没有“取消”功能，但它们非常有效，我认为您不需要至。无论如何，如果以这种方式实现main，则在启动操作时无需取消逻辑。

我不会检查用户是否输入了有效的二进制数字，而是确保他们只能输入数字0和1要开始的文本字段。只需将视图控制器指定为UITextField的委托，然后实现只接受二进制数字的shouldChangeCharactersInRange。

let nonBinaryCharacterSet = NSCharacterSet(charactersInString: "01").invertedSet

func textField(textField: UITextField, shouldChangeCharactersInRange range: NSRange, replacementString string: String) -> Bool {
    if string.rangeOfCharacterFromSet(nonBinaryCharacterSet) != nil {
        return false
    } else {
        return true
    }
}

正如您将在上面看到的那样，您不需要编写power方法。有一个内置函数，pow已经做到了。或者您可以使用按位移位运算符<<，这是执行二进制指数的有效方法。例如。提升到四次幂的2可以表示为1 << 4。

如何在swift中终止操作？

1 个答案: