Swift(4.0) 初见

Swift 是一门功能强大易于学习的编程语言 for macOS, iOS, watchOS, tvOS。 例如在 Swift 中，print("Hello, world!")，单行代码就是一个完整的程序，不需要为 print 函数导入单独的库。全局作用域中的代码会被作为程序的入口点，因此不需要 main() 函数，也不需要在行结尾加分号。

---

简单值

使用 let 声明常量，使用 var 声明变量。一个常量的值，并不需要有明确的值，但是只能为它赋值一次。常量和变量的类型必须和赋值一致，不需要明确声明类型，声明的同时进行赋值，编译器会自动推断类型。

var myVariable = 42
myVariable = 50
let myConstant = 42

如果没有初始值，或者初始值没有提供足够的信息，需要在变量后面声明类型。

let name: String
let implicitInteger = 70
let implicitDouble = 70.0
let explicitDouble: Double = 70

值不会隐式转化为其它类型，如果需要转化值到不同类型，需要显式转换。

let label = "The width is "
let width = 94
let widthLabel = label + String(width)

有一种把值转化为字符串更简单的方法，把值写在括号里，并且在括号前加一个反斜杠 \()。

let apples = 3
let oranges = 5
let appleSummary = "I have \(apples) apples."
let fruitSummary = "I have \(apples + oranges) pieces of fruit."

使用"""表示字符串占用多行

let quotation = """
I said "I have \(apples) apples."
And then I said "I have \(apples + oranges) pieces of fruit."
"""

使用[]创建数组和字典，访问它们的元素使用下标或者 key，最后一个元素后面允许有一个逗号。

var shoppingList = ["catfish", "water", "tulips", "blue paint"]
shoppingList[1] = "bottom of water"

var occupations = [
    "Malcolm": "Caption",
    "Kaylee": "Mechanic",
]
occupations["Jayne"] = "Public Relations"

创建空的数组或字典，可以使用初始化语法。

let emptyArray = [String]()
let emptyDictionary = [String: Float]()

如果类型信息可以推断，空数组可以使用[]创建，空字典可以 使用[:]创建

shoppingList = []
occupations = [:]

控制流

使用 if 和 switch 条件判断，使用 for-in,while,repeat-while循环操作。条件和循环变量括号可以省略，但是语法体的大括号不能省略。在if语法中，条件必须是一个布尔表达式，if score { …… }这样的代码会报错，不会隐式与 0 做对比。

let individualScores = [75, 43, 103, 87, 12]
var teamScore = 0
for score in individualScores {
    if score > 50 {
        teamScore += 3
    } else {
        teamScore += 1
    }
}
print(teamScore)

可以使用if和let处理值的缺失情况，这些值可以由可选值来代表。可选值可以是一个具体的值，也可以是nil表示值缺失。在类型后面添加一个问号标记这个变量是可选的。如果可选值为nil，条件就会为falsen，括号中的代码就会跳过。

var optionalString: String? = "Hello"
print(optionalString == nil)

var optionalName: String? = "John Appleseed"
var greeting = "Hello!"
if let name = optionalName {
    greeting = "Hello, \(name)"
}

另一种处理可选值是通过??操作符提供一个默认值

let nickName: String? = nil
let fullName: String = "John Appleseed"
let informalGreeting = "Hi \(nickName ?? fullName)"

switch支持任意类型的数据，不仅仅是整数。

let vegetable = "red pepper"
switch vegetable {
case "celery":
    print("Add some raisins and make ants on a log.")
case "cucumber", "watercress":
    print("That would make a good tea sandwich")
case let x where x.hasSuffix("pepper"):
    print("Is it a spicy \(x)?")
default:
    print("Everything tastes good in soup.")
}

可以使用for-in遍历字典，需要两个变量表示每个键值对。字典是无序集合，他们的键和值以任意顺序迭代结束。

let interestingNumbers = [
    "Prime":[2, 3, 5, 7, 11, 13],
    "Fibonacci":[1, 1, 2, 3, 5, 8],
    "Square":[1, 4, 9, 16, 25]
]
var largest = 0
for (_, numbers) in interestingNumbers {
    for number in numbers {
        if number > largest {
            largest = number
        }
    }
}
print(largest) //25

使用while重复某一段代码知道条件不满足，循环条件也可以在结尾，保证至少循环一次。

var n = 2
while n < 100 {
  n = n * 2
}
print(n)

var m = 2
repeat {
  m = m * 2
} while m < 100
print(m)

可以在循环中使用..<表示范围，使用..<创建范围不包括上界，如果需要包括使用...。

var iTotal = 0
var jTotal = 0
for i in 0..<4 {
    iTotal += i
}
print(iTotal) //6

for j in 0...4 {
    jTotal += j
}
print(jTotal) //10

函数和闭包

使用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("Bob", on: "Tuesday")

使用元组可以让函数返回多个值，元组的元素可以使用名称或数字表示。

func calculateStatistics(scores: [Int]) -> (min: Int, max: Int, sum: Int) {
    var min = scores[0]
    var max = scores[0]
    var sum = 0
    
    for score in scores {
        if score > max {
            max = score
        } else if score < min {
            min = score
        }
        sum += score
    }
    
    return (min, max, sum)
}
let statistics = calculateStatistics(scores:[5, 3, 100, 3, 9])
print(statistics.sum) //120
print(statistics.2) //120

函数可以嵌套，嵌套函数能够访问外部函数声明的变量，也可以使用嵌套函数重构太长或者复杂的代码。

func returnFifteen() -> Int {
    var y = 10
    func add() {
        y += 5
    }
    add()
    return y
}
returnFifteen() //15

函数是第一等类型，意味着函数可以作为另一个函数的返回值。

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

函数可以作为另一个函数的参数。

func hasAnyMatchs(list: [Int], condition: (Int) -> Bool) -> Bool {
    for item in list {
        if condition(item) {
            return true
        }
    }
    return false
}

func lessThanTen(number: Int) -> Bool {
    return number < 10
}

var number = [20, 19, 7, 12]
hasAnyMatchs(list: number, condition: lessThanTen) //true

函数实际是一个特殊的闭包，是一段之后能调用的代码段，闭包中的代码能够访问闭包作用域中能得到的变量和函数，即使闭包是在一个不同作用域被执行的，正如嵌套函数这个例子。可以使用({})创建一个匿名闭包，使用in将参数和返回值类型声明与比包体分离。

var number = [20, 19, 7, 12]
number.map({(number: Int) -> Int in
    let result = 3 * number
    return result
})

可以将闭包简化，如果闭包类型早已经知道，例如作为一个代理的回调，可以忽略参数的类型和返回值，单个语句闭包能把它语句的值当做结果返回。

let mappedNumbers = number.map({ number in 3 * number})
print(mappedNumbers) //[60, 57, 21, 36]

可以使用参数位置引用参数，当一个闭包作为最后一个参数传递给函数时，可以直接跟在函数后面，当闭包是唯一的参数时，可以忽略括号。

let sortedNumbers = number.sorted{ $0 > $1}
print(sortedNumbers) //[20, 19, 12, 7]

对象和类

使用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()

使用构造函数实例化对象，其中self用来区分实例变量。子类定义方法是在类后面加上父类名字，使用冒号分割，子类需要重写罚劣方法，使用override标记。

class NamedShape {
    var numberOfSides: Int = 0
    var name: String
    
    init(name: String) {
        self.name = name
    }
    
    func simpleDescription() -> String {
        return "A shape with \(numberOfSides) sides."
    }
}

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 side of length \(sideLength)."
    }
}

let test = Square(sideLength: 5.2, name: "my test square")
test.area()
test.simpleDescription()

除了存储属性之外，属性还有getter和setter。

    var sideLength: Double = 0.0
    
    init(sideLength: Double, name: String) {
        self.sideLength = sideLength
        super.init(name: name)
        numberOfSides = 3
    }
    
    var perimeter: Double {
        get {
            return 3.0 * sideLength
        }
        set {
            sideLength = newValue / 3.0
        }
    }
    
    override func simpleDescription() -> String {
         return "An equilateral triangle with sides of length \(sideLength)."
    }
}

var triangle = EquilateralTriangle(sideLength: 3.1, name: "a triangle")
print(triangle.perimeter) //9.3
triangle.perimeter = 9.9
print(triangle.sideLength) //3.3

如果不需要计算属性，需要设置一个新值之前或之后运行代码，可以使用willSet和didSet。

class TriangelAndSquare {
    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 = TriangelAndSquare(size: 10, name: "another test shape")
print(triangleAndSquare.square.sideLength) //10
print(triangleAndSquare.triangle.sideLength) //10
triangleAndSquare.square = Square(sideLength: 50, name: "large square")
print(triangleAndSquare.triangle.sideLength) //50

处理变量的可选值时，你可以在操作（比如方法、属性和子脚本）之前加?。如果?之前的值是nil，?后面的东西都会被忽略，并且整个表达式返回nil。否则，?之后的东西都会被运行。在这两种情况下，整个表达式的值也是一个可选值。

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

枚举和结构体

使用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 king = Rank.king //king
let aceRowValue = king.rawValue //13

上面例子中枚举原始值为Int，剩下的原始值按照顺序赋值，也可以使用字符串和浮点型作为原始值，使用rowValue属性访问枚举值原始值。使用init?(rowValue:)初始化构造器在原始值和枚举值之间转换。

if let convertedRank = Rank(rawValue: 1) {
    convertedRank.simpleDescription() //ace
}

枚举的成员值是实际值，并不是原始值的另一种表达方法。实际上，以防原始值没有意义，你不需要设置。有两种方式可以引用Hearts成员：给hearts常量赋值时，枚举成员Suit.Hearts需要用全名来引用，因为常量没有显式指定类型。在switch里，枚举成员使用缩写.Hearts来引用，因为self的值已经知道是一个suit。已知变量类型的情况下你可以使用缩写。

enum Suit {
   case spades, hearts, diamonds, clubs
   func simpleDescription() -> String {
       switch self {
       case .spades:
           return "spades"
       case .hearts:
           return "hearts"
       case .diamonds:
           return "diamonds"
       case .clubs:
           return "clubs"
       }
   }
}
let hearts = Suit.hearts
let heartDescription = hearts.simpleDescription()

一个枚举成员的实例可以有实例值。相同枚举成员的实例可以有不同的值。创建实例的时候传入值即可。实例值和原始值是不同的：枚举成员的原始值对于所有实例都是相同的，而且你是在定义枚举的时候设置原始值。

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

使用struct来创建一个结构体。结构体和类有很多相同的地方，比如方法和构造器。它们之间最大的一个区别就是结构体是传值，类是传引用。

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()

协议和拓展

使用protocal声明一个协议，类、枚举和结构体都可以实现协议。SimpleStructure时候mutating关键字用来标记一个会修改结构体的方法。SimpleClass的声明不需要标记任何方法，因为类中的方法通常可以修改类属性（类的性质）。

protocol ExampleProtocal {
    var simpleDescription: String { get }
    mutating func adjust()
}

class SimpleCalss: ExampleProtocal {
    var simpleDescription: String = "A very simple calss"
    var anotherProperty: Int = 69105
    func adjust() {
        simpleDescription += " Now 100% adjusted."
    }
}
var a = SimpleCalss()
a.adjust()
let aDescription = a.simpleDescription

struct SimpleStructure: ExampleProtocal {
    var simpleDescription: String = "A simple structure"
    mutating func adjust() {
        simpleDescription += " (adjusted)"
    }
}
var b = SimpleStructure()
b.adjust()
let bDescription = b.simpleDescription

使用extension为现有类型添加功能，比如新的方法和计算属性。

protocol ExampleProtocal {
    var simpleDescription: String { get }
    mutating func adjust()
}

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

print(7.simpleDescription)

错误处理

throws表示函数能抛出错误，throw抛出错误，如果函数抛出错误，函数立即返回。有几种方法捕获错误，其中一种是使用do-catch，在do内，通过在前面加try，表示代码能抛出错误，在catch内，能自动给出错误的名字。

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

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

do {
    let printerResponse = try send(job: 1040, toPrinter: "Never Has Toner")
    print(printerResponse)
} catch {
    print(error)
}

能写多个catch处理特殊的错误。

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?将结果转化为可选，如果函数抛出错误，特定的错误被丢弃结果为nil，否则结果是可选的，包含函数的返回值。

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

使用defer修饰的代码段会在所有代码之后，返回之前执行，不管是否抛出错误代码都被执行。

var fridgeIsOpen = false
let fridgeContent = ["milk", "eggs", "leftovers"]

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

泛型

在尖括号内部写一个名字创建一个泛型函数或者类型，也可以创建泛型函数、方法、类、枚举和结构体。。

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

在类型名后面使用where来指定对类型的需求，比如，限定类型实现某一个协议，限定两个类型是相同的，或者限定某个类必须有一个特定的父类。

func anyCommonElements <T: SequenceType, U: SequenceType where T.Generator.Element: Equatable, T.Generator.Element == U.Generator.Element> (lhs: T, _ rhs: U) -> Bool {
    for lhsItem in lhs {
        for rhsItem in rhs {
            if lhsItem == rhsItem {
                return true
            }
        }
    }
    return false
}
anyCommonElements([1, 2, 3], [3])