Swift项目实战-简单计算器

简介

斯坦福cs193p 2015年的冬季iOS8课程已经陆续上线了。说实话当我看到它上线的时候还是挺激动的，毕竟我也是从iOS6看到iOS7，每次都从那位 Paul Hegarty 做的demo中学到不少知识（哪怕抄一篇也是练手啊）。如果说乔布斯的本事是将复杂精密的电脑科技包装成一个简单美观且易用的iPhone并介绍给大众消费者的话，那么Paul老爷子的本事则是把复杂的iOS app开发通过他的课程和demo讲解的浅显易懂，帮助任何愿意成为iOS开发者的朋友能更好的熟悉开发和上手。引用他的话就是：一次demo演示胜过千言万语。但是前提是：首先要自己熟悉面向对象的概念，熟悉类和继承等等，否则越往后听就会越跟不上。

今年的iOS课程最大的亮点就是swift，就目前发布的视频来看，感觉斯坦福cs193p从今年起已经不再该课程中过多的介绍objective c了，所有的demo全部体现的是崭新的语言和思维。作为cs193p的粉丝，我也在这里发布自己的课后作业和解析，如有任何疑问或反馈，欢迎沟通。（相比较德国的rwth aachen大学，在今年推出的iOS8开发课程中仅有两节swift视频，如果有兴趣了解以objective c为基础的cocoa touch的朋友，可以从iTunes U下载他们的课程，很有帮助。）

概述

import UIKit

class ViewController: UIViewController {

    @IBOutlet weak var display: UILabel!

    // 用户是不是已经输入
    var userIsInTheMiddleOfTypingANumber:Bool = false

    @IBAction func appendDigit(sender: UIButton) {
        // Swift是非常强类型的语言
        // Swift有一个非常强大的特性,叫做类型推导
        let digit = sender.currentTitle!
        
        if userIsInTheMiddleOfTypingANumber {
            // 可选值(Optional)是不可以拼接字符串的,所以在这个地方,需要进行解包
            display.text = display.text! + digit
        } else {
            display.text = digit
            userIsInTheMiddleOfTypingANumber = true
        }
        print("digit = \(digit)")
    }
}

Tips

let用来定义常量（const），常量定义之后就不可以改变。一定要初始化，不初始化会报错。

var用来定义变量，一定要初始化，不初始化会报错。

swift语言有类型推导，定义的变量或者常量的类型通过右边的值来决定。

()用来在字符串中包含相应的变量或者常量

optional Type：这种类型的值有两种状态，一种是无值（nil），一种是有值。
也就是，Optional类型允许变量没有值，其它类型如果没有初始化值在使用时会报错。
optional 在有值得时候，值的类型是由？左边的值得类型来决定。可以通过！来解包取得相应的类型。
optional类型的值不可以用于右值！

按住option键点击相应的变量，来查看文档。

完成计算器，初探MVC设计模式

回车键及相关的代码

var operandStack = [Double]()
    @IBAction func enter() {
        userIsInTheMiddleOfTypingANumber = false
        operandStack.append(displayValue)
        print("operandStack = \(operandStack)")
    }

这个变量是一个内部的栈,去存储你输入的这些数,他的类型是一个数组,这个数组里存放的是Double的变量,注意在这个地方要初始化.（我们不能使用没有经过初始化的,会报错）

var operandStack: Array<Double> = Array<Double>()
var operandStack = Array<Double>()

// 用来进栈的数据
    var displayValue:Double {
        get {
            // 将字符串转换为double
            return NSNumberFormatter().numberFromString(display.text!)!.doubleValue
        }
        set {
            // 将value转换成字符串
            display.text = "\(newValue)"
            // 设置重新开始输入字符串
            userIsInTheMiddleOfTypingANumber = false
        }
    }

其中NSNumberFormatter类中比较常用的两个方法：

func stringFromNumber(number:NSNumber) -> String?
NSNumber 转换成String
func numberFromString(string:String) -> NSNumber?
String转换成 NSNumber
NSNumberFormatter().numberFromString(display.text!)!.doubleValue将字符串转换为NSnumber，然后将NSNumber转换为Double。
NSNumberFormatter()是用来初始化实例用的，这里是隐式，表示用对象来引用其中的方法。

加减乘除开根号运算

v0.7

    @IBAction func operate(sender: UIButton) {
        let operation = sender.currentTitle!
        
        if userIsInTheMiddleOfTypingANumber
        {
            enter()
        }
        
        switch operation {
        case "×":
            if operandStack.count >= 2 {
                displayValue = operandStack.removeLast() * operandStack.removeLast()
                enter()
            }
        case "÷":
            break
        case "+":
            break
        case "−":
            break
        default:
            break
        }
}

v0.8

    @IBAction func operate(sender: UIButton) {
        let operation = sender.currentTitle!
        
        if userIsInTheMiddleOfTypingANumber
        {
            enter()
        }
        
        switch operation {
        case "×": performOperation(multiply)
        case "÷":
            break
        case "+":
            break
        case "−":
            break
        default:
            break
        }
   }

    // 定义一个方法用来进行加减乘除运算,参数类型是一个方法:(Double, Double)->Double
    func performOperation(operation:(Double,Double) -> Double) {
        if operandStack.count >= 2 {  // 栈中必须有两个元素才能进行加减乘除的运算
            
            // 把最后的两个元素分别出栈,然后进行运算
            displayValue = operandStack.removeLast() * operandStack.removeLast()
            enter()
        }
    }
    
    func multiply(op1:Double, op2:Double) -> Double {
        return op1 * op2
    }

Swift中可以将一个方法作为另一个方法的参数：
performOperation(multiply)是将multiply方法作为performOperation方法的参数

v0.9

    @IBAction func operate(sender: UIButton) {
        let operation = sender.currentTitle!
        
        if userIsInTheMiddleOfTypingANumber
        {
            enter()
        }
        
        switch operation {
        case "×": performOperation({ (op1:Double, op2:Double) -> Double in
            return op1 * op2
        })
        case "÷":
            break
        case "+":
            break
        case "−":
            break
        default:
            break
        }
    }
    
    // 定义一个方法用来进行加减乘除运算,参数类型是一个方法:(Double, Double)->Double
    func performOperation(operation:(Double,Double) -> Double) {
        if operandStack.count >= 2 {  // 栈中必须有两个元素才能进行加减乘除的运算
            
            // 把最后的两个元素分别出栈,然后进行运算
            displayValue = operandStack.removeLast() * operandStack.removeLast()
            enter()
        }
    }

Swift中可以隐式的将一个方法作为另一个方法的参数

case "×": performOperation({ (op1:Double, op2:Double) -> Double in
            return op1 * op2
        })

可以看到隐式方法作为参数的时候，要放在{}里面，称之为闭包

Swift有类型自动推导的功能，所以可以简写为：

case "×": performOperation({ (op1,op2) in
            return op1 * op2
        })

performOperation({ (op1,op2) in return op1 * op2 })

performOperation({ (op1,op2) in op1 * op2 })

Swift中编译器会自动给方法中的参数传一个默认值,第一个参数$0,第二个参数$1........
所以可以继续简化为：

performOperation({ $0 * $1 })

Swift中如果一个方法是另外一个方法的最后一个参数，那么可以将此方法放到原方法后面：

performOperation() { $0 * $1 }

方法中无参数了可以直接去掉()

performOperation { $0 * $1 }

@IBAction func operate(sender: UIButton) {
        let operation = sender.currentTitle!
        
        if userIsInTheMiddleOfTypingANumber
        {
            enter()
        }
        
        switch operation {
        case "×": performOperation { $0 * $1 }
        case "÷": performOperation { $1 / $0 }  // 除数是栈中最先弹出的元素
        case "+": performOperation { $0 + $1 }
        case "−": performOperation { $1 - $0 }
        default: break
        }
    }
    
    // 定义一个方法用来进行加减乘除运算,参数类型是一个方法:(Double, Double)->Double
    func performOperation(operation:(Double,Double) -> Double) {
        if operandStack.count >= 2 {  // 栈中必须有两个元素才能进行加减乘除的运算
            
            // 把最后的两个元素分别出栈,然后进行运算
            displayValue = operation(operandStack.removeLast(),operandStack.removeLast())
            enter()
        }
    }

v1.0

import UIKit

class ViewController: UIViewController {

    @IBOutlet weak var display: UILabel!
    

    var userIsInTheMiddleOfTypingANumber:Bool = false

    @IBAction func appendDigit(sender: UIButton) {
        let digit = sender.currentTitle!
        
        if userIsInTheMiddleOfTypingANumber {
            display.text = display.text! + digit
        } else {
            display.text = digit
            userIsInTheMiddleOfTypingANumber = true
        }
        print("digit = \(digit)")
    }
    
    @IBAction func operate(sender: UIButton) {
        let operation = sender.currentTitle!
        
        if userIsInTheMiddleOfTypingANumber
        {
            enter()
        }
        
        switch operation {
        case "×": performOperation { $0 * $1 }
        case "÷": performOperation { $1 / $0 }
        case "+": performOperation { $0 + $1 }
        case "−": performOperation { $1 - $0 }
        case "√": performOperation { sqrt($0)}
        default: break
        }


    }
    
    // 定义一个方法用来进行加减乘除运算,参数类型是一个方法:(Double, Double)->Double
    func performOperation(operation:(Double,Double) -> Double) {
        if operandStack.count >= 2 {  // 栈中必须有两个元素才能进行加减乘除的运算
            // 把最后的两个元素分别出栈,然后进行运算
            displayValue = operation(operandStack.removeLast(),operandStack.removeLast())
            enter()
        }
    }
    
    // 添加private,不让Swift编译器将其暴露给Objective-C运行时
    private func performOperation(operation:Double -> Double)  {
        // 栈中必须多于一个元素才能进行开平方
        if operandStack.count >= 1 {
            displayValue = operation(operandStack.removeLast())
            enter()
        }
    }
    
    var operandStack = [Double]()
    
    @IBAction func enter() {
        userIsInTheMiddleOfTypingANumber = false
        
        operandStack.append(displayValue)
        
        print("operandStack = \(operandStack)")
        

    }
    
    // 用来进栈的数据
    var displayValue:Double {
        get {
            // 将字符串转换为double
            return NSNumberFormatter().numberFromString(display.text!)!.doubleValue
        }
        set {
            // 将value转换成字符串
            display.text = "\(newValue)"
            // 设置重新开始输入字符串
            userIsInTheMiddleOfTypingANumber = false
        }
    }
    
}

MVC设计模式初探

MVC设计模式

计算器的Model层

定义了一个私有的enum

 private enum Op {
        case Operand(Double)                                  // 操作数
        case UnaryOperation(String,Double -> Double)          // 一元运算
        case BinaryOperation(String,(Double,Double) ->Double) // 二元运算
}

声明了一个数组opStack和一个字典knownOps并初始化.

private var opStack = [Op]()
private var knownOps = [String:Op]()

 var knownOps = Dictionary<String,Op>()

简写为

 private var knownOps = [String:Op]()

函数的初始化

init() {
        knownOps["×"] = Op.BinaryOperation("×", *)
        knownOps["÷"] = Op.BinaryOperation("÷"){ $1 / $0}
        knownOps["+"] = Op.BinaryOperation("+", +)
        knownOps["−"] = Op.BinaryOperation("−"){ $1 - $0}
        knownOps["√"] = Op.UnaryOperation("√",sqrt)
    }

函数的初始化,为 knownOps 字典赋值,这里比较有趣,BinaryOperation 在定义需要的参数是一个 String 和函数（这个函数需要 2 个 Double 类型的参数，返回值是 Double 类型）, 而在初始化时这样写 knownOps["÷"] = Op.BinaryOperation("÷", { $1 / $0 }) 并不奇怪,有趣的是这里的闭包竟然可以直接省略成 * 和 + 就可以代表 (Double, Double) -> Double 了.这是因为在 Swift 里所有的操作符都是符号,* 其实就是代表 { $0 * $1 } 了,+ 代表 { $0 + $1 } ,所以可以直接省略写成 * 和 + ,至于 ÷ 和 − 后面的闭包 { $1 / $0 } 和 { $1 - $0 } 不能省略成 ÷ 和 − ,因为运算方向是相反的。

knownOps["×"] = Op.BinaryOperation("×"){ $0 * $1} 简写为
knownOps["×"] = Op.BinaryOperation("×", *)

knownOps["+"] = Op.BinaryOperation("+"){ $0 + $1} 简写为
knownOps["+"] = Op.BinaryOperation("+", +)

knownOps["√"] = Op.UnaryOperation("√"){ sqrt($0)} 简写为
knownOps["√"] = Op.UnaryOperation("√",sqrt)

evaluate

// 函数返回的是一个元组(Tuple),返回一个Tuple类型,里面有rusult和remainingOps
    private func evaluate(ops: [Op]) -> (result: Double?,remainingOps: [Op]) {
        if !ops.isEmpty {
            
            // 这里的 let op = ops.removeLast() 会报错,因为 ops 是一个不可变变量.
            // 为什么是一个不可变变量呢？swift 里规定,传过来的参数,除了类之外其他的都是值拷贝,类为引用.
            // 数组和字典都是结构体,所以是值拷贝,这点需要牢记。
            var remainingOps = ops
            let op = remainingOps.removeLast()
            
            switch op {
            case .Operand(let operand):
                return (operand,remainingOps)
            case .UnaryOperation(_, let operation):
                let operandEvaluation = evaluate(remainingOps) // 这样我就递归了
                if let operand = operandEvaluation.result {
                    return (operation(operand),operandEvaluation.remainingOps)
                }
            case .BinaryOperation(_, let operation):
                let op1Evalution = evaluate(remainingOps)
                if let operand1 = op1Evalution.result {
                    let op2Evalution = evaluate(op1Evalution.remainingOps)
                    if let operand2 = op2Evalution.result {
                        return (operation(operand1,operand2),op2Evalution.remainingOps)
                    }
                }
            }
        }
        return (nil,ops)
    }

递归计算栈示例

×
4

5
6
计算过程:4×(5+6)
我要再次递归,用于获取做加法的操作数
我得到5不错,我还要再次递归,得到一个6，填写到这里,这样,我计算完整个栈
就这样,你看到我这样通过来回递归,获取操作符所需要的操作数
一旦我取得的是操作数,本次递归就可以停止

CalculatorBrain.swift

import Foundation

// 作为计算器的Model层,这里将类命名为CalculatorBrain
class CalculatorBrain
{
    private enum Op {
        case Operand(Double)                                  // 操作数
        case UnaryOperation(String,Double -> Double)          // 一元运算
        case BinaryOperation(String,(Double,Double) ->Double) // 二元运算
        
        var desciption: String {
            get {
                switch self {
                case .Operand(let operand):
                    return "\(operand)"
                case .UnaryOperation(let symbol, _):
                    return symbol
                case .BinaryOperation(let symbol, _):
                    return symbol
                }
                
            }
        }
    }
    private var opStack = [Op]()
    
    private var knownOps = [String:Op]()

    init() {
        knownOps["×"] = Op.BinaryOperation("×", *)
        knownOps["÷"] = Op.BinaryOperation("÷"){ $1 / $0}
        knownOps["+"] = Op.BinaryOperation("+", +)
        knownOps["−"] = Op.BinaryOperation("−"){ $1 - $0}
        knownOps["√"] = Op.UnaryOperation("√",sqrt)
    }
    
    private func evaluate(ops: [Op]) -> (result: Double?,remainingOps: [Op]) {
        if !ops.isEmpty {
            var remainingOps = ops
            let op = remainingOps.removeLast()
            
            switch op {
            case .Operand(let operand):
                return (operand,remainingOps)
            case .UnaryOperation(_, let operation):
                let operandEvaluation = evaluate(remainingOps) // 这样我就递归了
                if let operand = operandEvaluation.result {
                    return (operation(operand),operandEvaluation.remainingOps)
                }
            case .BinaryOperation(_, let operation):
                let op1Evalution = evaluate(remainingOps)
                if let operand1 = op1Evalution.result {
                    let op2Evalution = evaluate(op1Evalution.remainingOps)
                    if let operand2 = op2Evalution.result {
                        return (operation(operand1,operand2),op2Evalution.remainingOps)
                    }
                }
            }
        }
        return (nil,ops)
    }
    
    func evaluate() -> Double? {
        // 令一个Tuple等于函数的返回值,_起占位作用,表示我不关心该参数。
        let (result,remainder) = evaluate(opStack)
        // opStack结果加上剩下的remainder
        print("\(opStack) = \(result) with \(remainder) left over")
        return result
    }
    
    func pushOperand(operand:Double) ->Double? {
        opStack.append(Op.Operand(operand))
        return evaluate()
    }
    
    func performOperation(symbol:String) -> Double? {
        if let operation = knownOps[symbol] {
            opStack.append(operation)
        }
        return evaluate()
    }

    
}

ViewController.swift

import UIKit

class ViewController: UIViewController {

    @IBOutlet weak var display: UILabel!
    
    var brain = CalculatorBrain()

    var userIsInTheMiddleOfTypingANumber:Bool = false

    @IBAction func appendDigit(sender: UIButton) {
        let digit = sender.currentTitle!
        
        if userIsInTheMiddleOfTypingANumber {
            display.text = display.text! + digit
        } else {
            display.text = digit
            userIsInTheMiddleOfTypingANumber = true
        }
        print("digit = \(digit)")
    }
    
    @IBAction func operate(sender: UIButton) {
        
        if userIsInTheMiddleOfTypingANumber
        {
            enter()
        }
        

        if let operation = sender.currentTitle {
            if let result = brain.performOperation(operation){
                displayValue = result
            } else {
                displayValue = 0
            }
            
        }

    }
    
    @IBAction func enter() {
        userIsInTheMiddleOfTypingANumber = false

        if let result = brain.pushOperand(displayValue){
            displayValue = result
        } else {
            displayValue = 0
        }
    }
    
    // 用来进栈的数据
    var displayValue:Double {
        get {
            // 将字符串转换为double
            return NSNumberFormatter().numberFromString(display.text!)!.doubleValue
        }
        set {
            // 将value转换成字符串
            display.text = "\(newValue)"
            // 设置重新开始输入字符串
            userIsInTheMiddleOfTypingANumber = false
        }
    }
    
}

最后编辑于：2017.12.03 21:24:54

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 214,313评论 6赞 496
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 91,369评论 3赞 389
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 159,916评论 0赞 349
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 57,333评论 1赞 288
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 66,425评论 6赞 386
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 50,481评论 1赞 292
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 39,491评论 3赞 412
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 38,268评论 0赞 269
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 44,719评论 1赞 307
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 37,004评论 2赞 328
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 39,179评论 1赞 342
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 34,832评论 4赞 337
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 40,510评论 3赞 322
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 31,153评论 0赞 21
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 32,402评论 1赞 268
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 47,045评论 2赞 365
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 44,071评论 2赞 352