做一个iOS的简单计算器(二)

接上一篇，我已经完成了多个小数点，除零，格式异常等处理，直接上代码，使用swift写的。
首先是一个处理栈等基本功能的类。

//定义一个处理基本操作的类
class CalculateTool: NSObject {
    var opndStack:Array<String>?    //运算数栈
    var optrStack:Array<String>?    //运算符栈
    
    //初始化运算数栈
    func initOpndStack()
    {
        opndStack = Array<String>()
    }
    //初始化运算符栈
    func initOptrStack(){
        optrStack = Array<String>()
    }
    //压入运算数
    func pushOperand(operand:String)
    {
        opndStack?.append(operand)
    }
    //压入运算符
    func pushOperator(optr:String)
    {
        optrStack?.append(optr)
    }
    //弹出一个运算数,返回弹出数:小数点也是数
    func popOperand() -> Float
    {
        if opndStack?.count > 0
        {
             let last = opndStack?.last
            opndStack?.removeLast()
            let lastString = last! as NSString
            return lastString.floatValue
        }
        return 0.0
    }
    //弹出一个运算符
    func popOperator() -> String
    {
        if optrStack?.count>0
        {
            let last = optrStack?.last
            optrStack?.removeLast()
            return last!
        }
        return ""
    }
    //取栈顶运算数
    func getTopOperand() -> Float
    {
        if opndStack?.count > 0
        {
            let last = opndStack?.last
            let lastString = last! as NSString
            return lastString.floatValue
        }
        return 0.0
    }
    //取栈顶运算符
    func getTopOperator() -> String
    {
        if optrStack?.count>0
        {
            let last = optrStack?.last
            return last!
        }
        return ""
    }
    //判断字符串是否为运算符
    func isOperator(c:String)->Bool
    {
        if c=="+" || c=="÷" || c=="×" || c=="－" || c=="=" || c=="(" || c==")"
        {
            return true
        }
        else
        {
            return false
        }
    }
    
    //判断运算符的优先级:栈内和栈外的区别
    func precedeInStack(s:String) -> Int
    {
        switch s {
        case "-":
            fallthrough
        case "+":
            return 2
        case "×":
            fallthrough
        case "÷":
            return 4
        case "(":
            return 0
        case ")":
            return 7
        default:
            return -1
        }
    }
    func precedeOutStack(s:String) -> Int
    {
        switch s {
        case "-":
            fallthrough
        case "+":
            return 1
        case "×":
            fallthrough
        case "÷":
            return 3
        case "(":
            return 7
        case ")":
            return 0
        default:
            return -1
        }
    }
    
    //进行单独的运算
    func operate(x:Float,opr:String,y:Float) -> Float
    {
        var result:Float?
        switch opr
        {
        case "+":
            result = x+y
            break
        case "-":
            result = x-y
            break
        case "×":
            result = x*y
            break
        case "÷":
            if y != 0
            {
                result = x/y
            }
            else
            {
                return PI
            }
            break
        default:
            result = 0
            break
        }
        return result!
    }
}

然后是一个处理运算表达式的类。

class CalculateResult: NSObject {
    var calculateTool:CalculateTool!
    
    override init() {
        super.init()
        calculateTool = CalculateTool()
        calculateTool.initOptrStack()
        calculateTool.initOpndStack()
    }
    //如何排除异常的表达式，包括小数点，除以0，其他格式
    func calculateWithString(s:String) -> Float
    {
        var calculateString = stringToArray(s)
        var result:Float = 0.0//初始化一个结果
        while calculateString.count>0
        {
            let firstElement = calculateString.first
            if firstElement?.componentsSeparatedByString(".").count>2
            {
                return PI
            }
            else if Float(firstElement!)==nil//如果是运算符,则比较优先级；多个小数点的情况
            {
                let topOptr = calculateTool.getTopOperator()
                //如果栈内运算符优先级较低,则运算符入栈
                if calculateTool.precedeInStack(topOptr)<calculateTool.precedeOutStack(firstElement!)
                {
                    calculateTool.pushOperator(firstElement!)
                    calculateString.removeAtIndex(0)
                    continue
                }
                //从符号栈弹出一个运算符，从对象栈弹出2个操作数，运算结果压入对象栈
                else if calculateTool.precedeInStack(topOptr)>calculateTool.precedeOutStack(firstElement!)
                {
                    let popOptr = calculateTool.popOperator()
                    let secondNumber = calculateTool.popOperand()
                    let firstNumber = calculateTool.popOperand()
                    let tempResult = calculateTool.operate(firstNumber, opr: popOptr, y: secondNumber)
                    if tempResult==PI//如果除以0
                    {
                        calculateTool.initOptrStack()
                        calculateTool.initOpndStack()
                        return PI
                    }
                    
                    calculateTool.pushOperand(String(tempResult))
                    continue
                }
                else//两个运算符相等时，从运算栈抵消
                {
                    let a = calculateTool.popOperator()
                    print("弹出的运算符为\(a)")
                    calculateString.removeAtIndex(0)
                    continue
                }
            }
            else//如果运算数则直接入栈，如果有两个小数点需要报错
            {
                calculateTool.pushOperand(firstElement!)
                calculateString.removeAtIndex(0)
                continue
            }
        }
        //上述步骤结束后那么剩下的运算符必然有序排列:从运算符栈弹出一个运算符，从运算数栈弹出两个运算数，将结果压入运算数
        while calculateTool.getTopOperator() != ""
        {
            let popOptr = calculateTool.popOperator()
            let secondNumber = calculateTool.popOperand()
            let firstNumber = calculateTool.popOperand()
            let tempResult = calculateTool.operate(firstNumber, opr: popOptr, y: secondNumber)
            calculateTool.pushOperand(String(tempResult))
        }
        result = calculateTool.getTopOperand()
        calculateTool.initOptrStack()
        calculateTool.initOpndStack()
        return result
    }
    
    
    //将输入的字符串输出为数组
    func stringToArray(s:String) -> Array<String>
    {
        var stringArray = Array<String>()
        var mutableStr = s
        while mutableStr.characters.count>0
        {
            let firstCharacter = mutableStr.substringToIndex(mutableStr.startIndex.advancedBy(1))
            if Int(firstCharacter)>=0 &&  Int(firstCharacter)<10//如果是数字
            {
                let length = mutableStr.characters.count
                
                //从前向后扫描
                for i in 0...length-1
                {
                    let character = mutableStr.substringWithRange(Range(start:mutableStr.startIndex.advancedBy(i),end:mutableStr.startIndex.advancedBy(i+1)))
                    print("该字符的整数值为\(Int(character))")
                    if Int(character)==nil && character != "."
                    {
                        let numberStr = mutableStr.substringToIndex(mutableStr.startIndex.advancedBy(i))
                        stringArray.append(numberStr)
                        mutableStr = mutableStr.substringFromIndex(mutableStr.startIndex.advancedBy(i))
                        break//跳出当次循环
                    }
                }
            }
            else//如果是运算符
            {
                stringArray.append(firstCharacter)
                mutableStr = mutableStr.substringFromIndex(mutableStr.startIndex.advancedBy(1))
            }
        }
        
        return stringArray
    }
  
}

界面用的UICollectionView，比较简单的。
用了几年的Object-c，思维习惯上还是转变不过来，代码里始终有着OC的影子，还在努力更正.

最近稍稍研究了一下JS在iOS中的应用，有些意思的。过一段时间再发。