Swift 语言学习及速查手册

学习一门新的编程语言要多久？答案是随着你的经验的增加，学习花费的时间越来越短。当然，这也和新语言的不断演变进化有关系。

我利用周末两天时间，把《Swift Programming Language》中文版整整的细看了一遍，然后为了总结提取 Swift 的主要语言特性，又把这本书快速过了第二遍。

根据我的番茄钟粗略统计，我看书学习第一遍大约花了 5 小时（包括边学，边在 XCode 试验的时间），第二遍主要是快速过一遍主要特性，将主要示例代码提取出来，大约花了 3.5 小时。

连我自己都觉得有点难以置信，总共只需要 8 小时，就可以基本入门一门新语言了。

很多时候，我们想学习某个东西，但是却一直停留在想一想的状态，迟迟都未动手。究其原因，大概是如下几个原因吧：

1. 恐惧未知。对未知的东西没有把握，怕太难，怕需要太长时间学，所以能拖就拖。

2. 注意力不能集中。连续玩几个小时游戏一点不累，看半小时书就感觉身心俱疲。

番茄工作法在这个时候就起作用了，告诉自己，不想太多，开始一个番茄钟试试，在这 25 分钟内，只关注这 25 分钟内要看的内容。然后，很自然的，障碍被逐个击破，番茄钟一个接着一个。

以下是我学习 Swift 的代码总结，可用于之后速查。

代码：https://github.com/coderzh/CodeTips/blob/master/swift.swift

/*
 swift.swift:
 Swift 速学速查速用代码手册
 Source: github.com/coderzh/CodeTips/blob/master/swift.swift
 Author: coderzh(github.com/coderzh)
 Blog: http://blog.coderzh.com
 参考：《Swift Programming Language》
 */

import Cocoa

// 0. 注释
/*
块注释
行尾分号可不用
*/

// 1. Hello World
print("Hello Swift")

// 2. 常量变量类型
let constValue = 3.14
var variable = 18

variable += 1

// 指定类型
let age: Int = 18
// 多重赋值
var (a, b) = (1, 2)
// 匿名占位符
(_, b) = (3, 4)

// 类型会自动推导
let name = "It's a string"
let gravity = 0.98 // 默认 double

// 永远不做隐式转换，必须自己强转
let sum = Double(age) + gravity

// 运算：+, -, *, /, % 求余
// 比较：<, >, ==, >=, <=, !=
// === 恒等，是否为同一个对象
// !== 不恒等
// 位运算：~x 取反，& 与，| 或，^ 异或，<< 左移动，>> 右移
// 溢出运算符 &+ &- &* &/ &% ，这样溢出部分就会丢掉，不会出错，比如：
var willOverflow = UInt8.max
willOverflow = willOverflow &+ 1 // = 0

// 类型
let b1 = true
let i32: Int32 = 6
let f64: Float64 = 3.1415

// 字符串
let str = "swift"
// 字符串连接，使用\()
var hello = "hello \(str)"
let count = str.characters.count
let c = hello[hello.startIndex]
for i in hello.characters.indices {
    print("\(hello[i])")
}

hello.insert("!", atIndex: hello.endIndex)
hello.insertContentsOf(" there".characters, at: hello.endIndex.predecessor())
hello.removeAtIndex(hello.endIndex.predecessor())
hello.hasPrefix("hello")
hello.hasSuffix("swift")

let unicode = "你好 swift"
unicode.characters.count // 8

for codeUnit in unicode.utf8 {
    print("\(codeUnit)", terminator: "")
}
if hello == unicode{

}

// 数组
var shoppingList = ["test", "book", "bike"]
shoppingList[2] = "joke"
shoppingList.append("bus")
shoppingList.insert("foo", atIndex: 0)
shoppingList.removeAtIndex(0)

// 类似 slice
shoppingList[0..<2] // ["test", "book"]
shoppingList[0...2] // ["test", "book", "joke"]

for item in shoppingList {
    print(item)
}

for (index, value) in shoppingList.enumerate() {
    print("\(index): \(value)")
}

let emptyArray = [String]()
var someInts = [Int]()
var someInts2 = [Int](count: 3, repeatedValue: 8) // [8, 8, 8]
var someInts3 = [Int](count: 3, repeatedValue: 2)

// 任意类型数组
var anyArray = [Any]()
anyArray.append(1)
anyArray.append("book")

someInts = someInts2 + someInts3 // [8, 8, 8, 2, 2, 2]

// 元组
let httpResponse = (404, "Not Found")
print(httpResponse.0)

// 集合 Sets
var setBooks: Set<String> = ["book1", "book2"]
// 自动推导
var setBooks2: Set = ["book1", "book2", "book3"]

setBooks.intersect(setBooks2)  // 交集
setBooks.exclusiveOr(setBooks2)  // 非交集
setBooks.union(setBooks2)  // 并集
setBooks.subtract(setBooks2)  // 减集

setBooks.isSubsetOf(setBooks2)
setBooks2.isSupersetOf(setBooks)
setBooks.isStrictSubsetOf(setBooks2)  // 被包含且不相等

// 字典
var map = [
    "Malcolm": "hehe",
    "Keylee": 123,
]
map["Keylee"] = 166

var namesOfInt = [Int: String]()
namesOfInt[10] = "ten"

if let oldValue = namesOfInt.updateValue("Ten", forKey: 10) {
    print("\(oldValue)")
}

if let name = namesOfInt[8] {
    print("\(name)")
} else {
    print("not exist 8")
}

for (intKey, strValue) in namesOfInt {
    print("\(intKey):\(strValue)")
}

// namsOfInt.values
for intKeys in namesOfInt.keys {

}

let intKeys = [Int](namesOfInt.keys)

// 可空变量，用 ?
var optionalString: String? = nil

if let name = optionalString {
    print("hello \(name)")
}

// 3. 流程控制
// 循环
// [0, 4)
for i in 0..<4 {
    print("print \(i)")  // 4 times
}

// [0, 4]
for i in 0...4 {
    print("print \(i)")  // 5 times
}

var i = 0
while i < 2 {
    print("\(i)")
    i += 1
}

repeat {
    print("\(i)")
    i += 1
} while i < 5

// 判断
if i < 5 {

} else if i < 10 {

} else {

}

// 强大的 switch
// 不需要 break
switch i {
case 1, 2, 3:
    print("123")
case 5:
    print("5")
case 6..<10:
    print("6-9")
default:
    print("default")
}

let somePoint = (1, 1)

switch somePoint {
case (0, 0):
    print("0, 0")
case (_, 1):
    print("y is 1")
case (-2...2, -2...2): // 区间
    print("from (-2,-2) to (2, 2)")
case (let x, 0):  // 值绑定
    print("\(x)")
case let (x, y) where x == y:  // where
    print("x == y")
case (10, 11):
    fallthrough  // 贯穿，继续向下
default:
    print("default")
}

// 控制转移
// continue break fallthrough retrun throw

// 带标签
i = 0
gameLoop: while i > -1 {
    i = i + 1
    if i > 3 {
        break gameLoop
    }
}

// 提前退出(提前返回)
func greet(person: [String:String]) {
    guard let name = person["name"] else {
        return
    }
    print("\(name)")
}

greet(["age":"18"])

// 4. 函数
func greet(name: String, day: String) {
    print("Hello \(name), today is \(day)")
}

// 第二个参数默认需要指定名称
greet("tom", day: "2016")

func sum(a: Int, b: Int) -> Int {
    return a + b
}

sum(1, b: 2)

// 多重返回值
func minMax(array: [Int]) -> (min: Int, max: Int) {
    // ...
    return (0, 1)
}

// 可选返回值加 ?
func minMax2(array: [Int]) -> (min: Int, max: Int)? {
    if array.isEmpty { return nil }
    return (0, 1)
}

// 指定外部参数名
func sayHello(to person: String, and anotherPerson: String) {
    print("Hello \(person) and \(anotherPerson)")
}

sayHello(to: "coderzh", and: "tom")

// 忽略外部参数名，使用 _
func sayHello2(person: String, _ anotherPerson: String) {
    print("Hello \(person) and \(anotherPerson)")
}

sayHello2("coderzh", "jack")

// 默认参数
func someFunction(p: Int = 10) {
    print("\(p)")
}

someFunction()

// 可变参数
func sum(numbers: Int...) -> Int {
    var total = 0
    for n in numbers {
        total += n
    }

    return total
}

sum(1, 2, 3, 4, 5)

// 参数默认是常量类型，如需指定变量类型，前面加 var（swift 3 将移除 var）
func alignRight(var string: String, totalLength: Int, pad: Character) -> String {
    string = string + "!"
    return string
}

// 传入传出参数 inout
func swap(inout a: Int, inout _ b: Int) {
    let temp = a
    a = b
    b = temp
}

var someInt = 7
var anotherInt = 8

// inout 参数必须加 &
swap(&someInt, &anotherInt)

// 函数类型，函数变量
var sumFunc: (Int, Int) -> Int = sum
sumFunc(1, 2)

// 函数可做参数
func doSum(handler:(Int, Int) -> Int, _ a: Int, _ b: Int) {
    handler(a, b)
}

// 函数可做返回值
func getSum() -> (Int, Int) -> Int {
    // 函数可嵌套
    func someFunc(a: Int, b: Int) -> Int { return a + b }
    return someFunc
}

doSum(sum, 2, 3)

// 闭包
// 闭包是引用类型
let reversed2 = shoppingList.sort({a, b in a < b})
let r = shoppingList.sort({ $0 < $1 })
let r2 = shoppingList.sort(<)
let r3 = shoppingList.sort{ $0 < $1 }

// 非逃逸闭包（noescape closure）
// 闭包只能在函数内执行，不能「逃逸」出去
func someClosure(@noescape closure: () -> Void) {
    closure()
}

// 自动闭包（这样不用写花括号了？）
func autoClosure(@autoclosure provider: () -> String) {
    provider()
}

autoClosure(shoppingList.removeAtIndex(0))

// 5. 枚举（一等公民，十分强大）
// 值类型
enum Rank: Int {
    case Ace = 1
    case Two, Three
}

var ace = Rank.Ace  // Ace
Rank.Ace.rawValue  // 1
let ace1 = Rank(rawValue: 1)  // Ace
ace = .Two

enum ServerResponse {
    case Result(String, String)
    case Error(String)
}

// 可失败构造器
enum TemperatureUnit {
    case Kelvin, Celsius, Fahrenheit
    init?(symbol: Character) {
        switch symbol {
        case "K":
            self = .Kelvin
        case "C":
            self = .Celsius
        case "F":
            self = .Fahrenheit
        default:
            return nil
        }
    }
}


let success = ServerResponse.Result("6:00am", "6:00pm")
let failure = ServerResponse.Error("Out of cheese")

switch success {
case let .Result(sunrise, sunset):
    let serverResponse = "sunrise at \(sunrise), sunset at \(sunset)"
case let .Error(error):
    let serverResponse = "Error \(error)"
}

// 枚举递归...
enum ArithmeticExpression {
    case Number(Int)
    indirect case Addition(ArithmeticExpression, ArithmeticExpression)
    indirect case Multiplication(ArithmeticExpression, ArithmeticExpression)
}

func evaluate(expression: ArithmeticExpression) -> Int {
    switch expression {
    case .Number(let value):
        return value
    case .Addition(let left, let right):
        return evaluate(left) + evaluate(right)
    case .Multiplication(let left, let right):
        return evaluate(left) * evaluate(right)
    }
}

// 计算 (5 + 4) * 2
let five = ArithmeticExpression.Number(5)
let four = ArithmeticExpression.Number(4)
let sum2 = ArithmeticExpression.Addition(five, four)
let product = ArithmeticExpression.Multiplication(sum2, ArithmeticExpression.Number(2))
print(evaluate(product)) // 输出 "18”

// 6. 类和结构体
// 结构体是值类型，类是引用类型
class SomeClass {
    var width = 0
    var height = 0

    // class 不需要 mutating
    func incrementWidth() {
        self.width += 1
    }

    // 下标操作： [n]
    subscript(index: Int) -> Int {
        get {
            return 0
        }
        set(newValue) {
            // set from newValue
        }
    }
}

let s1 = SomeClass()

struct SomeStruct {
    static var someValue = 100
    static func staticFunc() -> Int {
        return 1
    }

    var x = 0
    var y = 0

    var doubleX: Int {
        get {
            return x * 2
        }
        set {
            x = newValue / 2
        }
    }

    // readonly
    var doubleY: Int {
        return y * 2
    }

    var total: Int {
        willSet(newTotal) {
            print("will set \(newTotal)")
        }

        didSet {
            print("old: \(oldValue), new: \(total)")
        }
    }

    // 如果会改变类成员，比如声明 mutating
    mutating func incrementX() {
        self.x += 1
    }
}

var s2 = SomeStruct(x: 2, y: 3, total: 10)
s2.doubleX = 10  // s2.x == 5
s2.total = 5

// 继承
class Animal {
    // 构造函数
    init() {

    }

    // 必要构造器，子类必须实现，而且声明为 required
    required init(name: String, age: Int) {

    }

    func makeNoise() {
        print("wowowo")
    }
}

class Cat: Animal {
    var name: String = ""
    var nickName: String = ""

    init(name: String) {
        super.init()
        self.name = name
    }

    init(fromNickName nickName: String) {
        super.init(name: nickName, age: 18)
        self.nickName = nickName
    }

    // 便利构造器：必须调用其他构造器
    convenience override init() {
        self.init(name: "UnKnown")
    }

    // 可失败构造器
    init?(age: Int) {
        super.init(name: "UnKnown", age: age)
        if age < 0 { return nil }
    }

    required init(name: String, age: Int) {
        self.name = name
        super.init(name: name, age: age)
    }

    // 析构，默认会先调用父类的析构
    deinit {

    }

    override func makeNoise() {
        print("miaomiaomiao")
    }
}

final class CannotInheirt {

}

// 7. 自动引用计数 ARC
// weak 弱引用
// unowned 无主引用

// 8. 可空链式调用
/* For example:
if let johnsStreet = john.residence?.address?.street {
    print("John's street name is \(johnsStreet).")
} else {
    print("Unable to retrieve the address.")
}
*/
// 如果确定有值，使用!
// let roomCount = john.residence!.numberOfRooms


// 9. 错误处理

enum CustomError : ErrorType {
    case Invalid
    case OutOfRange
}

func makeASandwich() throws -> String {
    throw CustomError.Invalid
}

do {
    try makeASandwich()
} catch CustomError.Invalid {
    print("Invalid")
}

// 可空
let x = try? makeASandwich()
// 使错误传递失效，肯定不throw，否则 assert
// let y = try! makeASandwich()

// defer 和 Golang 里的 defer 一样，用来退出清理
/*
func processFile(filename: String) throws {
    if exists(filename) {
        let file = open(filename)
        defer {
            close(file)
        }
        while let line = try file.readline() {
            // 处理文件
        }
        // 在这里，作用域的最后调用 close(file)
    }
}
*/

// 10. 类型转换： is as （和 CSharp 类似）
// 任意类型：
// 1. AnyObject 任何 class 类型实例
// 2. Any 任何类型

// 11. 扩展（extension，类似 CSharp 里的扩展方法，但是貌似更强大）
// 比如：扩展内置类型 Double
// 几乎一切都可扩展，用到时再查用法吧
extension Double {
    var km: Double { return self * 1_000.0 }
    var m : Double { return self }
    var cm: Double { return self / 100.0 }
    var mm: Double { return self / 1_000.0 }
    var ft: Double { return self / 3.28084 }
}

// 12. 协议（类似接口的东西）
// 当同时有继承时，先写继承，再写协议，协议可以有多个
protocol FullyNamed {
    var fullName: String { get }
}

// 协议也可继承
protocol SubFullyNamed: FullyNamed {
    var nickName: String { get }
}

struct Person: FullyNamed{
    var fullName: String
}

// 专属协议，指定只能用在 class 上
protocol ClassOnlyProtocol: class, FullyNamed {

}

protocol Aged {
    var age: Int { get set }
}

// 协议合成
func foo(pro: protocol<FullyNamed, Aged>, base: Any) {
    // 协议判断
    if let p = base as? Aged {
        print(p.age)
    }
}

// 可选协议（既然是协议，还可选，醉了）
// @objc protocol

// 13. 泛型
func swapTwoValues<T>(inout a: T, inout _ b: T) {
    let temporaryA = a
    a = b
    b = temporaryA
}

// 泛型约束
func someFunction<T: SomeClass, U: FullyNamed>(someT: T, someU: U) {
    // 这里是函数主体
}

// Where
/*
func allItemsMatch<
    C1: Container, C2: Container
    where C1.ItemType == C2.ItemType, C1.ItemType: Equatable>
    (someContainer: C1, anotherContainer: C2) -> Bool {
}
*/

// 14. 访问控制
// public internal（默认） private
// 加在 class var 等前