Ios 如何在swift中终止操作？

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

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)
    }
}

导入UIKit
类ViewController:UIViewController{
@IBOutlet弱var textField:UITextField！
@IBVAR结果：UILabel！
var myArray=[Int]（）//Int的空数组
func转换（a:字符）->Int{
如果（a=“1”）{
返回1；
}
否则{
返回0；
}            
}
函数幂（a:Int，b:Int）->Int{
var结果=1
对于var i=0；i

在我最初的回答中（在这个问题的末尾），我回答了一个更加复杂的问题，即如何终止耗时的计算

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

问题的根源在于，您已将

myArray

定义为一个属性（在调用

binaryNumber

之间持续存在），而它应该是

binaryNumber

中的局部变量

例如：

// 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

改为局部变量；它解决了问题并避免了意外的后果），但这两种方法都可以解决您的问题

顺便说一句，下面是我最初的回答，讨论如何取消长时间运行的操作

--

有几点想法：

如果要取消某个操作，请添加一个指示是否取消该操作的布尔属性，并在计算循环中检查该变量的状态，以确定是否中止计算

但是，要使其工作，您必须在后台线程中进行计算。因此，后台线程将执行计算，主线程将处理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)
        }
    }
}

顺便说一下，使用函数式编程可以使上述

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)
    }
}

---

如上所述，您不需要编写

power

方法。有一个内置函数，

pow

，它已经做到了这一点。或者您可以使用位移位运算符，

考虑更好地格式化代码，选择Xcode中的代码，控制-i并重新缩进它。此外，大量的空白类使代码更难理解，一次可以看到的语句更少。问题中不需要包含未更改的苹果样板代码（或者根本不需要）。您所说的“终止操作”是什么意思？这种二进制转换非常快（特别是如果您对其进行了优化），我认为用户可能不需要取消它。你能解释一下你想做什么吗？我想他基本上想把
var myArray=[Int]（）
移到
binaryNumber
方法的开头。对不起，我犯了错误。我的问题应该是“如何重置阵列？”。罗布解决了这个问题。谢谢顺便说一句，你最初的答案很复杂。
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)
}

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)
    }
}

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
    }
}