特别声明：本篇文章由本人查阅官方文档和翻译软件的基础上进行翻译整理的。不存在任何抄袭他人文章行为。

2019年3月7日起编写

swift5.png

Swift是一种编写软件的极好语言，无论是用于手机、桌面电脑、服务器，还是其他运行代码的软件。它是一种安全、快速、交互式的编程语言，结合了现代语言中最优秀的思想，以及来自更广泛的苹果工程文化和开源社区的各种贡献的智慧。编译器针对性能进行了优化，语言也针对开发进行了优化，两者兼顾。

Swift 对编程初学者很友好。它是一种工业级的编程语言，与脚本语言一样具有表现力和趣味性。在“playground”上编写 Swift 代码可以让您体验代码并立即看到结果，而无需构建和运行应用程序。

Swift通过采用现代编程模式定义了大量常见的编程错误：

• 变量总是在使用前初始化。
• 检查数组索引是否存在越界错误。
• 检查整数是否溢出。
• 可选类型 Optional 确保显式处理nil值。
• 内存是自动管理的。
• 错误处理允许从意外故障中进行受控恢复。

Swift代码经过编译和优化，以最大限度地利用现代硬件。语法和标准库的设计遵循的指导原则是，编写代码的明显方式也应该是最好的。它的安全性和速度的结合使 Swift 成为一个优秀的选择，从“你好，世界!”到整个操作系统。

Swift将强大的类型推断和模式匹配与现代的轻量级语法结合起来，允许以清晰简洁的方式表达复杂的思想。因此，代码不仅更容易编写，而且更容易阅读和维护。

Swift已经开发了好几年，它还在不断地发展新的特性和功能。

注意： 本文档包含关于正在开发的API或技术的初步信息。此信息可能会发生更改，根据此文档实现的软件应该使用最终的操作系统软件进行测试。

本文档描述的是 Swift 5，也是Xcode 10.2的默认Swift 版本。。。Xcode 10.2 也支持 Swift 4 、Swift4.2 。

以下代码只适合于Swift 5：

• ？表达式不再为已经确定optional的对象提供其他optional
• 大型整数文字初始化表达式被推断为正确的整数类型。例如，UInt64(0xffff_ffff_ffff_ffff)的计算值是正确的，而不是溢出。

Swift 5 编写的目标可以依赖于 Swift 4.2 或 Swift 4 编写的目标，反之亦然。。。这意味着，如果您有一个被划分为多个框架的大型项目，您可以一次将代码从 Swift 4 迁移到 Swift 5。

Swift 之旅
比较传统的是，学习一门新语言时，都会打印 "Hello World"。 Swift 中一行代码完成：

print("Hello, world!")

这行代码是一个完整的程序。您不需要为输入/输出或字符串处理等功能导入单独的库。在全局作用域编写的代码用作程序的入口点，因此不需要main()函数。您也不需要在每个语句的末尾都写分号。

本教程通过向您展示如何完成各种编程任务，为您提供了足够的信息来开始使用Swift编写代码。如果你有什么不明白的地方，也不用担心——这本书的其余部分将详细介绍这次旅行的所有内容。

Simple Values 简单值

使用 let 来声明 一个常量，常量的值在编译时不需要知道，但是必须要赋值
使用 var 来声明 一个变量

var myVariable = 42
myVariable = 50
let myConstant = 42

---

常量或变量必须具有与要赋给它的值相同的类型。但是，您不必总是显式地编写类型。在创建常量或变量时提供一个值，可以让编译器推断其类型。

如果初值没有提供足够的信息(或者没有初值)，在变量后面加上冒号来指定类型。

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 = """
Even though there's whitespace to the left,
the actual lines aren't indented.
Except for this line.
Double quotes (") can appear without being escaped.
    """

---

使用 [] 来创建array，如下：

var shoppingList = ["fish","salt","water"]
print(shoppingList[2])

修改 array 中的元素，如下：

shoppingList[2] = "bottle of water"
print(shoppingList[2])

添加元素，如下：

shoppingList.append("apple")
print(shoppingList)

移除某个位置的元素，如下：

shoppingList.remove(at: 3)
print(shoppingList)

数组中元素不同类型时，需要在后面加上 as [Any]，如下：

let arr = ["abc",123] as [Any]
print(arr)

//创建一个空数组

let arrEmpty = [String]() 确定类型
var arrEmpty2 = [Any]() 任意类型

//如果类型已经确定了, 可以采取如下清空

shoppingList = []
print(shoppingList.isEmpty)

---

使用 [] 创建dictionary

var dicScore = ["Math":90, "Chinese":90]
print(dicScore["Math"]!) 

当字典中类型不一致时，需要 使用 as [String : Any] 来告诉编译器，value可以是任意类型

var dicPerson = ["name":"lxf", "age":12] as [String : Any]
print("这个人名字：\(dicPerson["name"]!)" + " ，年龄是：\(dicPerson["age"]!)")

以数值作为key

var dicNum = [1:"lisi",2:"zhangsan"]
print("第一名是："+dicNum[1]!+", 第二名是:\(dicNum[2]!)")
var dicNumDiff = [1:"lisi", 2:100] as [Int : Any]
print(dicNumDiff[1]!)

创建一个空字典

let dicEmpty = [String : String]()
let dicEmpty2 = [String : Any]()

如果字典已经确定 键值对类型，那么可以用如下清空方式：

dicScore = [:]
print(dicScore.isEmpty)

Control Flow 控制流

使用 if 和 switch 进行条件判断
使用 for-in，while，repeat-while 进行循环
小括号 () 可以省去，但是 花括号 { } 必须要!

let scores = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
for score in scores {
    if score >= 60 {
        print("恭喜您及格了！分数是:\(score)")
    } else{
        print("真遗憾，您未及格！分数是：\(score)")
    }
}

您可以使用 if 和 let 来处理可能丢失的值。
一个可选值要么包含一个值，要么包含一个空值，以指示一个值丢失。
在值的类型后面写一个问号(?)，将该值标记为可选的。

var optionalString: String? = "Hello"
print(optionalString == nil)   //输出 false

var optionalName: String? = "John Appleseed"
var greeting = "Hello!"
if let name = optionalName {
    greeting = name
} else{
    greeting = "name 为 nil"
}
print(greeting) 
输出  "John Appleseed"

如果将 optionalName 设置为nil

var optionalName: String? = "John Appleseed"
var greeting = "Hello!"
optionalName = nil
if let name = optionalName {
    greeting = name
} else{
    greeting = "name 为 nil"
}
print(greeting) 
输出  "name 为 nil"

总结：if let 一起使用时，判断是否为nil，如果为nil，那么执行else语句，否则执行if语句

---

处理可选值的另一种方法是使用 ?? 操作符。
表达式为: optionalValue ?? defaultValue
如果可选值为nil时，则使用默认值。

let nickName: String? = nil
let fullName: String = "李四"
let informalGreeting = "Hi \(nickName ?? fullName)"
print(informalGreeting)
输出 李四


let nickName2: String? = "狗蛋"
let fullName2: String = "李四"
let informalGreeting2 = "Hi \(nickName2 ?? fullName2)"
print(informalGreeting2)
输出 狗蛋

---

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.")
}
// Prints "Is it a spicy red pepper?"

如果去掉default ，那么会出现红色报错 switch must be exhaustive，告诉我们switch语句必须是详尽的

---

使用 for-in 来遍历字典中的所有 key-value，输出最大值

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 (kind, numbers) in interestingNumbers {
    for number in numbers {
        if number > largest {
            largest = number
        }
    }
}
print(largest)
输出 25

但是，会出现一个 黄色警告：

Immutable value 'kind' was never used; consider replacing with '' or removing it_
意思是：使用_下划线替换 kind 这个没有使用的变量名
按照这个提示，将 kind 替换 _ 即可。尽量不出现黄色警告！

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

//使用 for-in 来遍历字典中的所有 key-value, 查找最大值，并输出最大值类型

let interestingNumbers = [
    "Prime": [2, 3, 5, 7, 11, 13],
    "Fibonacci": [1, 1, 2, 3, 5, 8],
    "Square": [1, 4, 9, 16, 25],
]
var type : String? = nil
var max = 0
for (kind, numbers) in interestingNumbers {
    for number in numbers {
        if number > max {
            max = number
            type = kind
        }
    }
}
print("最大值为：\(max), 类型为：\(type ?? "")")
输出 最大值为：25, 类型为：Square

---

while condition {...} 和 repeat{...} while condition
// 前者先判断条件
// 后者先执行一次

var n = 4
var ni = 0
while n < 100 {
    n *= 2
    ni += 1
}
print("while 循环执行了 \(ni) 次，结果为 \(n)")
输出 while 循环执行了 5 次，结果为 128

var m = 1
var mi = 0
repeat {
    m *= 4
    mi += 1
} while m < 100
print("repeat while 循环执行了 \(mi) 次，结果为 \(m)")
输出 repeat while 循环执行了 4 次，结果为 256

---

索引循环

..< 循环符号

var total = 0
for i in 0..<4 {
    total += i
    print(i)
}
print("结果为：" + String(total))
结果为：6 , 从i=0开始执行，最后执行i=3, 执行了4次。

... 循环符号

total = 0
for i in 0...4 {
    total += i
    print(i)
}
print("结果为：" + String(total))
//结果为：10 , 从i=0开始执行，最后执行i=4, 执行了5次。

---

从一组考试成绩，分级 不及格，良好，优秀

//let scores = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
for score in scores {
    switch score {
    case  ...60:
        print("不及格! 您的分数为：\(score)")
        break
    case 60 ..< 80:
            print("良好! 您的分数为：\(score)")
        break
    case 80...:
        print("优秀! 您的分数为：\(score)")
        break
    default:
        print("您没有参加考试")
    }
}

打印结果为

不及格! 您的分数为：0
不及格! 您的分数为：10
不及格! 您的分数为：20
不及格! 您的分数为：30
不及格! 您的分数为：40
不及格! 您的分数为：50
良好! 您的分数为：60
良好! 您的分数为：70
优秀! 您的分数为：80
优秀! 您的分数为：90
优秀! 您的分数为：100

...说明

• i...n
  从 i 开始，依次执行到 n 执行之后结束
• i..<n
  从 i 开始，依次执行到 n 执行之前结束
• i...
  从 i 开始 , 到最大值结束
• ...n
  从最小值开始，到 n 结束

---

Functions and Closures 函数和闭包

函数的声明和调用

有参数和返回值，多个参数用 ，隔开
func greet(person:String) -> String{
    return "Hello \(person)"
}
print(greet(person: "狗蛋"))

有参数，无返回值
func eat(food:String){
    print("晚餐吃：\(food)")
}
eat(food: "面条")

无参数，有返回值
func drunk() -> String{
    return "我喝完了"
}
print(drunk())

无参数，无返回值
func resigned(){
    print("辞职了，没有收入，真可怜！")
}
resigned()

默认情况下，函数使用它们的参数名作为参数的标签。
在参数名之前编写一个自定义参数标签，或者编写 _ 来使用无参数标签。

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

func fly(name:String, from originCity:String, to destination:String){
    print("乘客：\(name) 从 \(originCity) 飞往 \(destination) 的航班即将起飞，请抓紧时间")
}
fly(name:"李狗蛋", from:"上海", to: "芜湖")
输出 乘客：李狗蛋 从 上海 飞往 芜湖 的航班即将起飞，请抓紧时间

---

以 元组 作为返回值：元组中元素为最小值，最大值，和。

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

---

函数可以作为返回值: ((paramType) -> returnType)

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

---

函数可以作为参数: 判断数组中是否有小于10的数，有返回true，没有返回false

是否小于10
func lessThanTen(number: Int) -> Bool {
    return number < 10
}
func hasAnyMatches(list: [Int], condition: (Int) -> Bool) -> Bool {
    for item in list {
        if condition(item) {
            return true
        }
    }
    return false
}
var numbers = [20, 19, 7, 12]
hasAnyMatches(list: numbers, condition: lessThanTen)

---

函数实际上是闭包的一种特殊情况:稍后可以调用的代码块。
闭包中的代码可以访问在创建闭包的作用域中可用的变量和函数，即使闭包在执行时处于不同的作用域中——您已经看到了一个使用嵌套函数的例子。
您可以通过使用大括号{} 包围代码来编写没有名称的闭包。用于将参数和返回类型与主体分离。

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

输出结果:

60
57
21
36

如何理解？
遍历数组中元素 number, 然后计算返回一个值。注意此时数组中的元素仍然是原来的数据。

---

您有几个选项可以更简洁地编写闭包。
当闭包的类型已知时，例如委托的回调，您可以省略它的参数类型、返回类型，或者两者都省略。
单个语句闭包隐式地返回它们唯一语句的值。

var numbers = [20, 19, 7, 12]
let mappedNumbers = numbers.map({ number in 3 * number })
print(mappedNumbers)

输出结果:

60
57
21
36

如何理解？
number 为遍历的元素
in 代表遍历
3*number 代表返回值

---

您可以通过数量而不是名称引用参数，这种方法在非常短的闭包中特别有用。
作为函数的最后一个参数传递的闭包可以出现在圆括号之后。
当闭包是函数的唯一参数时，可以完全省略括号。

从大到小排序：

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

同理将 大于符号> 改为 小于符号< 那么将从小到大排序

---

Objects and Classes 对象和类

类的声明和使用

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

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

通过在类名后面加上括号来创建类的实例。
使用点语法访问实例的属性和方法。

给类添加一个构造方法

class NamedShape {
    var numberOfSides: Int = 0
    var name: String

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

    func simpleDescription() -> String {
        return "A shape with \(numberOfSides) sides."
    }
}

注意self是如何用于区分name属性、name参数和初始化器的。在创建类的实例时，初始化器的参数像函数调用一样传递。每个属性都需要一个赋值——要么在声明中赋值(如numberOfSides)，要么在初始化器中赋值(如name)。

如果需要在释放对象之前执行一些清理，请使用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()

圆

class Circle:NamedShape{
    var radius : Double
    init(name: String, radius:Double) {
        self.radius = radius
        super.init(name: name)
    }
    func area() -> Double {
      return radius * radius * Double.pi
    }
    
    override func simpleDescription() -> String {
        return "A circle with radius of length \(radius)"
    }
}

let circle = Circle(name: "Circle", radius: 5)
print(circle.area())
print(circle.simpleDescription())

---

除了存储的简单属性外，属性还可以有getter和setter。
等边三角形

class EquilateralTriangle: NamedShape {
    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)

triangle.perimeter = 9.9
print(triangle.sideLength)

在周长的setter中，新值具有隐式名称newValue。您可以在set之后的括号中提供显式名称。

注意EquilateralTriangle类的初始化器有三个不同的步骤:

• 设置子类声明的属性的值。
• 调用了父类的构造方法
• 更改超类定义的属性的值。此时还可以执行使用方法、getter或setter的任何附加设置工作。

如果您不需要计算属性，但仍然需要提供在设置新值之前和之后运行的代码，那么使用willSet和didSet。只要值在初始化器之外发生更改，就会运行您提供的代码。
例如，下面的类确保三角形的边长总是与其正方形的边长相同。

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)

在使用可选类型的对象时，你可以在调用方法，属性，下标前先写 ？操作符。如果对象是nil，？后面内容的将被忽略，整个表达式为nil，否则，可选值将被展开，？操作符后面的内容将作用在展开值上。
在这两种情况下，整个表达式的值都是一个可选值。

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

let sideLength = optionalSquare?.sideLength

---

Enumerations and Structures 枚举和结构体

枚举

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)
        }
    }
    func compare(r:Rank) -> Int {
        var result = 0
        if self.rawValue > r.rawValue {
            result = 1
        } else if self.rawValue < r.rawValue{
            result = -1
        }
        return result
    }
}
let ace = Rank.ace
let aceRawValue = ace.rawValue

let r1 = Rank.ace
let r2 = Rank.king
let result = r1.compare(r: r2)
print(result)

默认情况下，Swift分配的原始值从0开始，每次递增1，但您可以通过显式指定值来更改此行为。在上面的示例中，Ace被显式地给定一个原始值1，其余的原始值按顺序分配。还可以使用字符串或浮点数作为枚举的原始类型。使用rawValue属性访问枚举用例的原始值。

如果 rawValue 不是有意义的，就不需要提供

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"
        }
    }
    func color() -> String {
        switch self {
        case .spades, .clubs:
            return "black"
        case .hearts, .diamonds:
            return "red"
        }
    }
}
let hearts = Suit.hearts

let heartsDescription = hearts.simpleDescription()

结构体

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

思考：写一个函数，来生成一副扑克牌?

Protocols and Extensions 协议和扩展

协议

使用 protocol 关键字来声明一个 协议

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

类、枚举和结构都可以采用协议。

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 Int: ExampleProtocol {
    var simpleDescription: String {
        return "The number \(self)"
    }
    mutating func adjust() {
        self += 42
    }
}
print(7.simpleDescription)

练习：写一个扩展实现 类型为Double的绝对值absoluteValue计算属性

您可以像使用任何其他命名类型一样使用协议名称—例如，创建具有不同类型但都符合单个协议的对象集合。当处理类型为协议类型的值时，不能使用协议定义之外的方法。

let protocolValue: ExampleProtocol = a
print(protocolValue.simpleDescription)

即使变量protocolValue有一个SimpleClass的运行时类型，编译器仍然将它视为给定类型的ExampleProtocol。这意味着除了协议一致性之外，您不能意外地访问类实现的方法或属性。

Error Handling 错误处理

你可以采用遵守 Error 协议的任何类型来呈现错误信息。
如枚举：

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

使用throw来抛出错误，并使用throw来标记可能抛出错误的函数。如果在函数中抛出错误，函数将立即返回，调用该函数的代码将处理该错误。

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

处理错误的两种方式：

• 通过 do{...}catch{...} do代码块中调用可能抛出错误的函数，catch代码块中返回错误
• 在调用函数前加上 try? 如果抛出错误，函数返回nil，否则返回可选值

方式一
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)
}

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

defer{}

defer{} 代码块写在函数中，特性为：在函数中其他所有代码执行后才会执行defer代码块的语句

var isOk = false
var isFalse = false
func testDefer(){
    defer {
        isOk = false
    }
    defer {
        isOk = true
        isFalse = true
    }
    print("函数内部输出的isOk = \(isOk)")
}
testDefer()
print("函数外部输出的isOk = \(isOk)")
print("函数外部输出的isFalse = \(isFalse)")

控制台打印结果为：

函数内部输出的isOk = false
函数外部输出的isOk = false
函数外部输出的isFalse = true

可以得出结论：如果函数内部有多个 defer，从最下面的defer依次向上执行defer代码块

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)

重新实现Swift标准库的可选类型

enum OptionalValue<Wrapped> {
    case none
    case some(Wrapped)
}
var possibleInteger: OptionalValue<Int> = .none
possibleInteger = .some(100)

使用泛型时，可以在函数主体{}前添加 where 语句
where 关键词右边语句 可以要求泛型实现某种协议，可以要求两种类型一致，可以要求一个类有个特定的超类

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