Version Compatibility

当使用Swift 4 的编译器来编译Swift 3 的代码时候，编译器会把它标记为3.2。所以，可以使用条件编译block，例如 if swift(>=3.2) 来编写代码，以达到对多个版本的兼容。

A Swift Tour

swift语句是不需要使用分号结束的。

Simple Values

使用 let 声明常量，var 声明变量。

let explicitDouble: Double = 70
let implicitInteger = 70

swift 可以根据我们给变量赋的初值来判断变量的类型，转换变量类型必须显示转换。
使用""" """声明多行string。使用[]声明数组和字典，使用index 或 key 访问数组和字典内的元素。

Control Flow

if 和 switch 做条件判断，for-in, while, repeat-while做循环。条件可以不使用（）包裹，执行体必须使用{}包裹。

var optionalString: String? = "Hello"

optionalString 是一个optional变量，表示它可能包含一个值，可能是nil。
关于optional变量，有几种特殊用法。

if let name = optionalString {
print(name)
}

let info = "Hi \(nickName ?? "zhangsan")"

switch 支持各种类型数据，而不只是integer。当满足某种case，执行完毕改case的代码块，会立即退出，所以不需要在每个case代码块后写break。

0 ..< 4 => [0, 1, 2, 3]
0 ... 4 => [0, 1, 2, 3, 4]

Functions and Closures

使用 func 声明函数，使用 -> 分离函数列表和函数返回值。

func greet(person: String, day: String) -> String {
    return "Hello \(person), today is \(day)."
}
greet(person: "Bob", day: "Tuesday")

func greet(_ person: String, on day: String) -> String {
    return "Hello \(person), today is \(day)."
}
greet("John", on: "Wednesday")

函数的返回值和参数都可以是一个函数。

func makeIncrementer() -> ((Int) -> Int) {
    func addOne(number: Int) -> Int {
        return 1 + number
    }
    return addOne
}
var increment = makeIncrementer()
increment(7)

函数是一种特殊的闭包，闭包使用{}包裹代码块，使用 in 分割参数、返回值 和 代码体。

numbers.map({ (number: Int) -> Int in
    let result = 3 * number
    return result
})

Objects and Classes

使用class声明函数，函数内属性和方法的声明跟变量和方法声明相同。

class Shape {
    var numberOfSides = 0
    func simpleDescription() -> String {
        return "A shape with \(numberOfSides) sides."
    }
}

使用类名后跟括号获得类的实例，使用点语法获得类中的属性和方法。

var shape = Shape()
shape.numberOfSides = 7
var shapeDescription = shape.simpleDescription()

关于继承，如果某个类的父类是根类，没有必要显示的写上继承于根类。如果要继承的话，需要在类名后面写上父类，使用：分割。
如果对象dealloc的时候要做一些清楚操作，可以做deinit方法。

class Square: NamedShape {
    var sideLength: Double
    
    init(sideLength: Double, name: String) {
        self.sideLength = sideLength
        super.init(name: name)
        numberOfSides = 4
    }
    
    func area() -> Double {
        return sideLength * sideLength
    }
    
    override func simpleDescription() -> String {
        return "A square with sides of length \(sideLength)."
    }
}
let test = Square(sideLength: 5.2, name: "my test square")
test.area()
test.simpleDescription()

上述类的init方法，有三步：
1.给子类种的属性赋值
2.调用父类的init方法
3.改变父类定义的属性的值。其他的使用setter等方法的配置工作也可以在这里完成。

如果要重写父类中的方法，必须标上override；如果某个方法不是重写父类的方法，不要标记override。编译器会检查上述两种情况。

也可以给属性设置setter和getter方法：

var perimeter: Double {
        get {
            return 3.0 * sideLength
        }
        set {
            sideLength = newValue / 3.0
        }
    }

setter的参数，默认使用newValue。

如果不想计算属性，但是想在设置改属性值之前或之后运行某段代码，可以使用willSet和didSet。在initializer之外改改变属性的值，会调用你提供的那段代码。

class TriangleAndSquare {
    var triangle: EquilateralTriangle {
        willSet {
            square.sideLength = newValue.sideLength
        }
    }
    var square: Square {
        willSet {
            triangle.sideLength = newValue.sideLength
        }
    }
    init(size: Double, name: String) {
        square = Square(sideLength: size, name: name)
        triangle = EquilateralTriangle(sideLength: size, name: name)
    }
}

var triangleAndSquare = TriangleAndSquare(size: 10, name: "another test shape")
print(triangleAndSquare.square.sideLength)
print(triangleAndSquare.triangle.sideLength)
triangleAndSquare.square = Square(sideLength: 50, name: "larger square")
print(triangleAndSquare.triangle.sideLength)

当操作optional 变量的时候，可以在操作后面加？，包括获取属性值、调用方法等。如果？前的值是nil，那么？后的内容会被忽略，整个内容也是nil。否则，？之后的内容都会被运行。这两种情况下，整个表达式的值也是一个可选值。

let optionalSquare: Square? = Square(sideLength: 2.5, name: "optional square")
let sideLength = optionalSquare?.sideLength

Enumerations and Structures

使用enum创建枚举，枚举内可以有自己的函数。

enum Rank: Int {
    case ace = 1
    case two, three, four, five, six, seven, eight, nine, ten
    case jack, queen, king
    func simpleDescription() -> String {
        switch self {
        case .ace:
            return "ace"
        case .jack:
            return "jack"
        case .queen:
            return "queen"
        case .king:
            return "king"
        default:
            return String(self.rawValue)
        }
    }
}
let ace = Rank.ace
let aceRawValue = ace.rawValue

swift默认从0开始赋值，我们可以明确给定一个值改变这种行为。
使用rawValue属性取得枚举的原始值。
给常量ace赋值，使用的是Rank.ace，因为ace的类型未知；在枚举内部使用的是简略语法.ace，因为这个时候是知道类型的。 我们可以在任何已知枚举类型的地方使用简略语法。
使用 init?(rawValue:) 初始化一个枚举，它可能会返回一个与rawValue匹配的枚举，或者nil。

if let convertedRank = Rank(rawValue: 3) {
    let threeDescription = convertedRank.simpleDescription()
}

枚举的枚举值的rawValue是声明的时候就确定的，所以枚举的相同枚举case在任何时候都是相同的；但是枚举的不同实例的相同case可能不同。🌰：

enum ServerResponse {
    case result(String, String)
    case failure(String)
}
 
let success = ServerResponse.result("6:00 am", "8:09 pm")
let failure = ServerResponse.failure("Out of cheese.")

switch success {
case let .result(sunrise, sunset):
    print("Sunrise is at \(sunrise) and sunset is at \(sunset).")
case let .failure(message):
    print("Failure...  \(message)")
}

ServerResponse.result.rawValue = 0。 但是，上述的result的值为 上午六点和下午八点。可能有一个实例的result值是不同的时间点。

上述代码块解析：
1.success 和 failure 都是ServerResponse类型。
2.常量success的值是reslut（rawValue = 0）。
3.switch success ，应该这样说：switch ServerResponse类型的一个常量，它的结果有两种.result 和 .failure

使用struct创建结构体。

结构体支持类的许多行为，比如methods 和 initializers。它们最大的不同是：结构题的传递是copy的，而类是reference的。

struct Card {
    var rank: Rank
    var suit: Suit
    func simpleDescription() -> String {
        return "The \(rank.simpleDescription()) of \(suit.simpleDescription())"
    }
}
let threeOfSpades = Card(rank: .three, suit: .spades)
let threeOfSpadesDescription = threeOfSpades.simpleDescription()

Protocols and Extensions

使用protocal声明协议，类、枚举、结构体都可以实现协议。

class SimpleClass: ExampleProtocol {
    var simpleDescription: String = "A very simple class."
    var anotherProperty: Int = 69105
    func adjust() {
        simpleDescription += "  Now 100% adjusted."
    }
}
var a = SimpleClass()
a.adjust()
let aDescription = a.simpleDescription
 
struct SimpleStructure: ExampleProtocol {
    var simpleDescription: String = "A simple structure"
    mutating func adjust() {
        simpleDescription += " (adjusted)"
    }
}
var b = SimpleStructure()
b.adjust()
let bDescription = b.simpleDescription

在SimpleStructure结构体中，有个方法被mutating关键字修饰了，表明这个方法会改变结构体。SimpleClass类中的方法不需要标记mutating，因为类中的方法总是要改变类的。

可以使用 extension为现有类型增加功能，例如增加方法和计算属性。

你可以使用extension让一个在其他地方定义的类型、甚至是你从一个框架和库导入的类型来遵循某个协议，来改变它的定义。

extension Int: ExampleProtocol {
    var simpleDescription: String {
        return "The number \(self)"
    }
    mutating func adjust() {
        self += 42
    }
}
print(7.simpleDescription)

你可以使用协议名，就像使用其他命名类型一样来创建一个包含各种不同类型但都遵守一个协议的集合对象。当你使用这些类型是协议类型的变量时，只能调用该协议里的方法。

Error Handing

使用遵循了Error协议的类型来表示错误。

enum PrinterError: Error {
    case outOfPaper
    case noToner
    case onFire
}

使用throw抛出错误，使用throws关键字表示方法可以抛出错误。如果在方法里抛出错误，方法会立即返回，并切调用方法的代码处理错误。

func send(job: Int, toPrinter printerName: String) throws -> String {
    if printerName == "Never Has Toner" {
        throw PrinterError.noToner
    }
    return "Job sent"
}

这有几种处理错误的方式。一种是使用do-catch。在do block中，在方法前面使用try标记，表明它可能会抛出错误。在catch block内，错误被自动命名为error，除非你明确给出其他名字。

do {
    let printerResponse = try send(job: 1040, toPrinter: "Bi Sheng")
    print(printerResponse)
} catch {
    print(error)
}

可以使用多个catch block 来处理特定的错误。就像在switch中那样写case。

do {
    let printerResponse = try send(job: 1440, toPrinter: "Gutenberg")
    print(printerResponse)
} catch PrinterError.onFire {
    print("I'll just put this over here, with the rest of the fire.")
} catch let printerError as PrinterError {
    print("Printer error: \(printerError).")
} catch {
    print(error)
}

另一种处理错误的方式是使用 try? 把函数返回转成optional类型。如果函数抛出了错误，那么错误会被抛弃，结果会是nil。否则结果会是一个返回值类型的optional变量。

let printerSuccess = try? send(job: 1884, toPrinter: "Mergenthaler")
let printerFailure = try? send(job: 1885, toPrinter: "Never Has Toner")

在函数中使用defer标记的代码块将会被最后执行（return 之前）。不管函数是否抛出错误，这块代码都会被执行。

func fridgeContains(_ food: String) -> Bool {
    fridgeIsOpen = true
    defer {
        fridgeIsOpen = false
    }
    
    let result = fridgeContent.contains(food)
    return result
}

Generics

在<>内写一个名字来创建范型函数或范型类型。

func makeArray<Item>(repeating item: Item, numberOfTimes: Int) -> [Item] {
    var result = [Item]()
    for _ in 0..<numberOfTimes {
        result.append(item)
    }
    return result
}
makeArray(repeating: "knock", numberOfTimes: 4)

不仅可以创建范型函数、方法，还可以创建范型类、枚举、结构体。

enum OptionalValue<Wrapped> {
    case none
    case some(Wrapped)
}