简介

斯坦福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 = Array()
var operandStack = Array()

// 用来进栈的数据
    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()

简写为

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

Swift项目实战-简单计算器

简介

概述