1.3 Swift 初览
原文链接: https://docs.swift.org/latest/documentation/the-swift-programming-language/guidedtour/
1.3 Swift 初览
概览 Swift 的特性与语法。
按照传统，学习一门新语言时的第一个程序都应该在屏幕上打印 “Hello, world!"。在 Swift 里，一行代码就能做到：
1
2
| print("Hello, world!")
// 输出 "Hello, world!"
|
如果你接触过其他语言，这段语法应该让你感到熟悉——在 Swift 里，这一行就是一个完整的程序。你不需要为了输出文本或处理字符串之类的功能而单独引入某个库。写在全局作用域里的代码就是程序的入口，因此也不需要 main() 函数，更不需要在每条语句末尾写分号。
这一节巡览会带你完成各种各样的编程任务，让你掌握足够的信息，可以开始用 Swift 写代码。有看不懂的地方不必担心——本节出现的一切，在本书后面都会详细讲解。
简单值
用 let 声明常量，用 var 声明变量。常量的值不必在编译期就已知，但你必须且只能给它赋值一次。也就是说，你可以用常量为一个只确定一次、却要在多处使用的值起个名字。
1
2
3
| var myVariable = 42
myVariable = 50
let myConstant = 42
|
常量或变量的类型必须与你要赋给它的值一致。不过，类型并非总要显式写出。在创建常量或变量时提供一个值，编译器就能推断出它的类型。在上面的例子里，由于初始值是整数，编译器推断 myVariable 是整数。
如果初始值提供的信息不够（或者根本没有初始值），就在变量名后面用冒号引出类型。
1
2
3
| let implicitInteger = 70
let implicitDouble = 70.0
let explicitDouble: Double = 70
|
实验：创建一个类型显式声明为 Float、值为 4 的常量。
值永远不会被隐式转换成其他类型。如果你需要把某个值转换成别的类型，就显式地构造一个目标类型的实例。
1
2
3
| let label = "The width is "
let width = 94
let widthLabel = label + String(width)
|
实验：试着把最后一行里对 String 的转换去掉，你会得到什么错误？
还有一种更简单的办法可以把值放进字符串：把值写在圆括号里，并在圆括号前加上反斜杠（\）。例如：
1
2
3
4
| let apples = 3
let oranges = 5
let appleSummary = "I have \(apples) apples."
let fruitSummary = "I have \(apples + oranges) pieces of fruit."
|
实验：用 \() 把一次浮点运算的结果放进字符串，
并把某个人的名字放进一句问候语中。
对于跨多行的字符串，使用三个双引号（"""）。只要每行开头的缩进与结尾引号的缩进一致，这些缩进就会被去掉。例如：
1
2
3
4
5
6
7
8
| 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.
I still have \(apples + oranges) pieces of fruit.
"""
|
用方括号（[]）创建数组和字典，并把下标或键写在方括号里来访问元素。最后一个元素后面允许写逗号。
1
2
3
4
5
6
7
8
| var fruits = ["strawberries", "limes", "tangerines"]
fruits[1] = "grapes"
var occupations = [
"Malcolm": "Captain",
"Kaylee": "Mechanic",
]
occupations["Jayne"] = "Public Relations"
|
数组会随着元素的加入自动增长。
1
2
3
| fruits.append("blueberries")
print(fruits)
// 输出 "["strawberries", "grapes", "tangerines", "blueberries"]"。
|
同样用方括号来写空数组和空字典：数组写作 []，字典写作 [:]。
1
2
| fruits = []
occupations = [:]
|
如果你要把空数组或空字典赋给一个新变量，或者用在没有类型信息的地方，就必须写出类型。
1
2
| let emptyArray: [String] = []
let emptyDictionary: [String: Float] = [:]
|
控制流
用 if 和 switch 写条件分支，用 for-in、while 和 repeat-while 写循环。条件或循环变量外面的圆括号可以省略，但循环体外面的花括号是必须的。
1
2
3
4
5
6
7
8
9
10
11
| let individualScores = [75, 43, 103, 87, 12]
var teamScore = 0
for score in individualScores {
if score > 50 {
teamScore += 3
} else {
teamScore += 1
}
}
print(teamScore)
// 输出 "11"。
|
在 if 语句中，条件必须是布尔表达式——也就是说，if score { ... } 这样的代码会报错，它并不会被理解为与零做隐式比较。
你可以把 if 或 switch 写在赋值语句的等号（=）后面，或者写在 return 之后，从而根据条件来挑选一个值。
1
2
3
4
5
6
7
| let scoreDecoration = if teamScore > 10 {
"🎉"
} else {
""
}
print("Score:", teamScore, scoreDecoration)
// 输出 "Score: 11 🎉"。
|
你可以把 if 和 let 搭配使用，来处理可能缺失的值。这类值用可选类型表示。可选值要么包含一个值，要么包含 nil 表示值缺失。在值的类型后面写一个问号（?），就把它标记为可选。
1
2
3
4
5
6
7
8
9
10
| var optionalString: String? = "Hello"
print(optionalString == nil)
// 输出 "false"。
var optionalName: String? = "John Appleseed"
var greeting = "Hello!"
if let name = optionalName {
greeting = "Hello, \(name)"
}
print(greeting)
|
实验：把 optionalName 改成 nil，你会得到什么样的问候语？
再添加一个 else 分支：当 optionalName 为 nil 时，
让它设置另一种问候语。
如果可选值是 nil，条件就是 false，花括号里的代码会被跳过。否则，可选值会被解包并赋给 let 后面的常量，这个被解包的值在代码块内部就可以使用了。
处理可选值的另一种做法是用 ?? 运算符提供一个默认值：如果可选值缺失，就改用默认值。
1
2
3
| let nickname: String? = nil
let fullName: String = "John Appleseed"
let informalGreeting = "Hi \(nickname ?? fullName)"
|
解包时还可以用更简短的写法：让解包后的值沿用同一个名字。
1
2
3
4
| if let nickname {
print("Hey, \(nickname)")
}
// 因为 nickname 是 nil，所以什么都不会输出。
|
switch 支持任何类型的数据，也支持多种多样的比较操作——它并不局限于整数和相等判断。
1
2
3
4
5
6
7
8
9
10
11
12
| 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.")
}
// 输出 "Is it a spicy red pepper?"。
|
实验：试着把 default 分支删掉，你会得到什么错误？
注意这里 let 如何用在模式中，把与该模式匹配的值赋给一个常量。
匹配到的 case 里的代码执行完之后，程序就从 switch 语句中退出，不会继续执行下一个 case，因此你不需要在每个 case 的代码末尾显式写出 break。
用 for-in 遍历字典时，需要提供一对名字来分别接收每个键值对。字典是无序集合，所以它的键和值会以任意顺序被遍历。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| 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 重复执行一段代码，直到条件发生变化。循环条件也可以放在末尾，这样能保证循环体至少执行一次。
1
2
3
4
5
6
7
8
9
10
11
12
13
| var n = 2
while n < 100 {
n *= 2
}
print(n)
// 输出 "128"。
var m = 2
repeat {
m *= 2
} while m < 100
print(m)
// 输出 "128"。
|
实验：把条件从 m < 100 改成 m < 0，
看看当循环条件一开始就为假时，
while 和 repeat-while 的行为有什么不同。
用 ..< 生成一个下标范围，就能在循环中维护一个下标。
1
2
3
4
5
6
| var total = 0
for i in 0..<4 {
total += i
}
print(total)
// 输出 "6"。
|
用 ..< 生成的是不包含上界的范围，用 ... 生成的则是包含上下界的范围。
函数与闭包
用 func 声明函数。调用函数时，在函数名后面跟一对圆括号，把实参写在里面。用 -> 把参数名和参数类型与函数的返回类型分隔开。
1
2
3
4
| func greet(person: String, day: String) -> String {
return "Hello \(person), today is \(day)."
}
greet(person: "Bob", day: "Tuesday")
|
实验：把 day 参数删掉，
再添加一个参数，把今天的午餐特餐写进问候语。
默认情况下，函数会把参数名用作实参标签。你也可以在参数名前写一个自定义的实参标签，或者写 _ 表示不使用实参标签。
1
2
3
4
| func greet(_ person: String, on day: String) -> String {
return "Hello \(person), today is \(day)."
}
greet("John", on: "Wednesday")
|
用元组（tuple）把多个值组合成一个复合值——比如让函数一次返回多个结果。元组的元素既可以用名字引用，也可以用序号引用。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| 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"。
|
函数可以嵌套。嵌套函数能够访问在外层函数中声明的变量。当一个函数又长又复杂时，可以用嵌套函数来组织其中的代码。
1
2
3
4
5
6
7
8
9
| func returnFifteen() -> Int {
var y = 10
func add() {
y += 5
}
add()
return y
}
returnFifteen()
|
函数是一等类型。这意味着函数可以把另一个函数当作自己的返回值。
1
2
3
4
5
6
7
8
| func makeIncrementer() -> ((Int) -> Int) {
func addOne(number: Int) -> Int {
return 1 + number
}
return addOne
}
var increment = makeIncrementer()
increment(7)
|
函数也可以把另一个函数作为自己的参数之一。
1
2
3
4
5
6
7
8
9
10
11
12
13
| func hasAnyMatches(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 numbers = [20, 19, 7, 12]
hasAnyMatches(list: numbers, condition: lessThanTen)
|
函数其实只是闭包（closure）的一种特例：闭包是可以稍后再调用的一段代码。闭包里的代码能够访问创建该闭包的作用域中可用的变量和函数，即使闭包执行时处在另一个作用域——前面嵌套函数的例子已经展示了这一点。把代码用花括号（{}）括起来，就能写出一个没有名字的闭包。用 in 把参数和返回类型与闭包体分开。
1
2
3
4
| numbers.map({ (number: Int) -> Int in
let result = 3 * number
return result
})
|
实验：改写这个闭包，让所有奇数都返回零。
闭包还有几种更简洁的写法。当闭包的类型已经已知时，比如作为委托的回调，你可以省略参数类型、返回类型，或者两者都省略。只有一条语句的闭包会隐式返回这条语句的值。
1
2
3
| let mappedNumbers = numbers.map({ number in 3 * number })
print(mappedNumbers)
// 输出 "[60, 57, 21, 36]"。
|
也可以用序号而不是名字来引用参数——在很短的闭包中这种方式特别方便。作为函数最后一个参数传入的闭包可以直接写在圆括号后面。如果闭包是函数唯一的参数，你甚至可以完全省略圆括号。
1
2
3
| let sortedNumbers = numbers.sorted { $0 > $1 }
print(sortedNumbers)
// 输出 "[20, 19, 12, 7]"。
|
对象与类
用 class 加上类名来创建类。类中属性声明的写法和常量、变量的声明一样，只不过它处在类的上下文中。方法声明与函数声明的写法同样如此。
1
2
3
4
5
6
| class Shape {
var numberOfSides = 0
func simpleDescription() -> String {
return "A shape with \(numberOfSides) sides."
}
}
|
实验：用 let 添加一个常量属性，
再添加一个带参数的方法。
在类名后面加一对圆括号，就创建了这个类的一个实例。用点语法访问实例的属性和方法。
1
2
3
| var shape = Shape()
shape.numberOfSides = 7
var shapeDescription = shape.simpleDescription()
|
这个版本的 Shape 类缺少一件重要的东西：在创建实例时用来初始化对象的构造器。用 init 来创建构造器。
1
2
3
4
5
6
7
8
9
10
11
12
| 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 创建反初始化器。
子类在类名后面写上父类名，用冒号分隔。Swift 不要求类必须继承某个标准根类，因此你可以按需保留或省略父类。
子类中覆盖父类实现的方法必须加上 override 标记——如果不加 override 就意外覆盖了某个方法，编译器会把它当作错误；同样，如果加了 override 却没有真正覆盖父类中的任何方法，编译器也会报错。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| 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()
|
实验：再给 NamedShape 写一个名为 Circle 的子类，
让它的构造器接收半径和名字作为实参，
并在 Circle 类上实现 area() 和 simpleDescription() 方法。
除了简单的存储属性，属性还可以带有取值器和设值器。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
| 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)
// 输出 "9.3"。
triangle.perimeter = 9.9
print(triangle.sideLength)
// 输出 "3.3000000000000003"。
|
在 perimeter 的设值器里，新值有一个隐式名字 newValue。你也可以在 set 后面的圆括号里给出明确的名字。
注意 EquilateralTriangle 的构造器包含三个不同的步骤：
- 给子类声明的属性赋值。
- 调用父类的构造器。
- 修改父类定义的属性值。使用方法、取值器或设值器的其他初始化工作也可以在这时进行。
如果你不需要计算属性，但又想在设置新值的前后执行一些代码，就用 willSet 和 didSet。只要值在构造器之外发生变化，你提供的代码就会执行。例如下面这个类，它保证三角形的边长始终等于正方形（square）的边长。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
| 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)
// 输出 "10.0"。
print(triangleAndSquare.triangle.sideLength)
// 输出 "10.0"。
triangleAndSquare.square = Square(sideLength: 50, name: "larger square")
print(triangleAndSquare.triangle.sideLength)
// 输出 "50.0"。
|
处理可选值时，可以在方法、属性、下标等操作前面写 ?。如果 ? 前面的值是 nil，那么 ? 后面的一切都会被忽略，整个表达式的值就是 nil；否则可选值会被解包，? 后面的操作都作用于解包后的值。无论哪种情况，整个表达式的值都是可选值。
1
2
| let optionalSquare: Square? = Square(sideLength: 2.5, name: "optional square")
let sideLength = optionalSquare?.sideLength
|
枚举与结构体
用 enum 创建枚举。和类以及其他所有具名类型一样，枚举也可以带有关联的方法。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| 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
|
实验：写一个函数，通过比较原始值来比较两个 Rank 值。
默认情况下，Swift 从零开始、每次递增一来分配原始值，但你可以显式指定取值来改变这种行为。在上面的例子里，Ace 被显式赋予原始值 1，其余的原始值按顺序依次分配。枚举的原始类型也可以是字符串或浮点数。用 rawValue 属性访问枚举成员的原始值。
用 init?(rawValue:) 构造器可以从原始值创建枚举实例。它返回与该原始值匹配的枚举成员；如果没有匹配的 Rank，就返回 nil。
1
2
3
| if let convertedRank = Rank(rawValue: 3) {
let threeDescription = convertedRank.simpleDescription()
}
|
枚举的成员值就是实实在在的值，而不仅仅是书写其原始值的另一种方式。事实上，如果一个枚举没有有意义的原始值，你完全可以不提供原始值。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| 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 heartsDescription = hearts.simpleDescription()
|
实验：给 Suit 添加一个 color() 方法，
让黑桃和梅花返回 “black”，红桃和方块返回 “red”。
注意上面引用枚举成员 hearts 的两种方式：给 hearts 常量赋值时，枚举成员用的是完整名字 Suit.hearts，因为这个常量没有显式指定类型；而在 switch 里面，枚举成员用的是简写形式 .hearts，因为 self 的值已经知道是一张花色。只要值的类型已经确定，就可以使用简写形式。
如果枚举带有原始值，那么这些值在声明时就已经确定，也就是说，某个枚举成员的每个实例的原始值都完全相同。枚举成员还有一种选择，就是携带与成员关联的值（associated value）——这些值在你创建实例时才确定，而且同一个枚举成员的不同实例可以携带不同的值。你可以把关联值理解为该枚举成员实例的存储属性。举个例子：假设要向服务器请求日出和日落时间，服务器要么返回所请求的信息，要么返回一段说明哪里出了问题的描述。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| 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)")
}
// 输出 "Sunrise is at 6:00 am and sunset is at 8:09 pm."。
|
实验：给 ServerResponse 和上面这个 switch 各添加第三个成员。
注意日出和日落时间是如何在与 switch 各分支匹配的过程中，从 ServerResponse 值里提取出来的。
用 struct 创建结构体。结构体支持与类相同的许多行为，包括方法和构造器。结构体与类最重要的区别之一是：结构体在代码中传递时总是被复制，而类是按引用传递的。
1
2
3
4
5
6
7
8
9
| 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()
|
实验：写一个函数，返回由一副完整的牌组成的数组，
其中每种点数和花色的组合各有一张牌。
并发
用 async 标记异步运行的函数。
1
2
3
4
5
6
| func fetchUserID(from server: String) async -> Int {
if server == "primary" {
return 97
}
return 501
}
|
在异步函数的调用前面写 await，就表示这是一次异步调用。
1
2
3
4
5
6
7
| func fetchUsername(from server: String) async -> String {
let userID = await fetchUserID(from: server)
if userID == 501 {
return "John Appleseed"
}
return "Guest"
}
|
用 async let 调用异步函数，可以让它与其他异步代码并行运行。使用它返回的值时，要写 await。
1
2
3
4
5
6
| func connectUser(to server: String) async {
async let userID = fetchUserID(from: server)
async let username = fetchUsername(from: server)
let greeting = await "Hello \(username), user ID \(userID)"
print(greeting)
}
|
用 Task 可以从同步代码中调用异步函数，而不必等待它们返回。
1
2
3
4
| Task {
await connectUser(to: "primary")
}
// 输出 "Hello Guest, user ID 97"。
|
用任务组（task group）来组织并发代码。
1
2
3
4
5
6
7
8
9
10
11
12
13
| let userIDs = await withTaskGroup(of: Int.self) { group in
for server in ["primary", "secondary", "development"] {
group.addTask {
return await fetchUserID(from: server)
}
}
var results: [Int] = []
for await result in group {
results.append(result)
}
return results
}
|
actor 与类相似，区别在于 actor 能保证不同的异步函数可以同时安全地与同一个 actor 实例交互。
1
2
3
4
5
6
7
8
9
10
| actor ServerConnection {
var server: String = "primary"
private var activeUsers: [Int] = []
func connect() async -> Int {
let userID = await fetchUserID(from: server)
// ... 与服务器通信 ...
activeUsers.append(userID)
return userID
}
}
|
调用 actor 的方法或访问它的属性时，要给这段代码加上 await，表示它可能需要等待已经在该 actor 上运行的其他代码结束。
1
2
| let server = ServerConnection()
let userID = await server.connect()
|
协议与扩展
用 protocol 声明协议。
1
2
3
4
| protocol ExampleProtocol {
var simpleDescription: String { get }
mutating func adjust()
}
|
类、枚举和结构体都可以采纳协议。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| 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
|
实验：再给 ExampleProtocol 添加一条要求，
为了让 SimpleClass 和 SimpleStructure 仍然满足该协议，
你需要做哪些修改？
注意 SimpleStructure 的声明中用 mutating 关键字标记了会修改结构体的方法。SimpleClass 的声明则不需要把任何方法标记为 mutating，因为类的方法总是可以修改该类。
用 extension 为已有的类型添加功能，例如新方法和计算属性。你可以用扩展让一个在别处声明的类型（甚至是某个库或框架中导入的类型）采纳协议。
1
2
3
4
5
6
7
8
9
10
| extension Int: ExampleProtocol {
var simpleDescription: String {
return "The number \(self)"
}
mutating func adjust() {
self += 42
}
}
print(7.simpleDescription)
// 输出 "The number 7"。
|
实验：为 Double 类型写一个扩展，
添加一个 absoluteValue 属性。
协议名可以像其他具名类型一样使用——比如用它来创建一个集合，其中的对象类型各不相同，但都采纳了同一个协议。当值的类型是被装箱的协议类型（boxed protocol type）时，协议定义之外的方法不可用。
1
2
3
4
| let protocolValue: any ExampleProtocol = a
print(protocolValue.simpleDescription)
// 输出 "A very simple class. Now 100% adjusted."。
// print(protocolValue.anotherProperty) // 取消注释即可看到错误
|
尽管变量 protocolValue 的运行时类型是 SimpleClass，编译器仍然把它当作 ExampleProtocol 类型处理。这意味着你无法意外访问该类在协议之外额外实现的方法或属性。
错误处理
用任何采纳了 Error 协议的类型来表示错误。
1
2
3
4
5
| enum PrinterError: Error {
case outOfPaper
case noToner
case onFire
}
|
用 throw 抛出错误，用 throws 标记可能抛出错误的函数。如果在函数中抛出了错误，函数会立即返回，由调用该函数的代码负责处理这个错误。
1
2
3
4
5
6
| func send(job: Int, toPrinter printerName: String) throws -> String {
if printerName == "Never Has Toner" {
throw PrinterError.noToner
}
return "Job sent"
}
|
处理错误有好几种办法。一种是使用 do-catch。在 do 代码块中，把可能抛出错误的代码用 try 标记出来；在 catch 代码块中，错误会自动被命名为 error，除非你给它另取一个名字。
1
2
3
4
5
6
7
| do {
let printerResponse = try send(job: 1040, toPrinter: "Bi Sheng")
print(printerResponse)
} catch {
print(error)
}
// 输出 "Job sent"。
|
实验：把打印机名改成 "Never Has Toner"，
让 send(job:toPrinter:) 函数抛出一个错误。
你可以提供多个 catch 代码块来处理特定的错误。在 catch 后面写模式，就像在 switch 的 case 后面写模式一样。
1
2
3
4
5
6
7
8
9
10
11
| 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)
}
// 输出 "Job sent"。
|
实验：在 do 代码块里添加代码来抛出错误。
你需要抛出什么样的错误，
才会由第一个 catch 代码块处理？
第二个和第三个代码块又分别处理什么？
处理错误的另一种办法是用 try? 把结果转换成可选值。如果函数抛出错误，具体的错误会被丢弃，结果是 nil；否则结果是一个包含函数返回值的可选值。
1
2
| let printerSuccess = try? send(job: 1884, toPrinter: "Mergenthaler")
let printerFailure = try? send(job: 1885, toPrinter: "Never Has Toner")
|
用 defer 写一段在函数中所有其他代码之后、函数返回之前执行的代码。无论函数是否抛出错误，这段代码都会执行。用 defer 可以把成对的准备代码与清理代码写在一起，即使它们的执行时机相隔很远。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| 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
}
if fridgeContains("banana") {
print("Found a banana")
}
print(fridgeIsOpen)
// 输出 "false"。
|
泛型
把名字写在尖括号里，就能定义泛型函数或泛型类型。
1
2
3
4
5
6
7
8
| 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)
|
函数和方法可以写成泛型的，类、枚举和结构体同样可以。
1
2
3
4
5
6
7
| // 重新实现 Swift 标准库中的可选类型
enum OptionalValue<Wrapped> {
case none
case some(Wrapped)
}
var possibleInteger: OptionalValue<Int> = .none
possibleInteger = .some(100)
|
在函数体之前用 where 指定一组要求——比如要求某个类型实现某个协议、要求两个类型相同，或者要求某个类具有特定的父类。
1
2
3
4
5
6
7
8
9
10
11
12
13
| 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, 3], [3])
|
实验：修改 anyCommonElements(_:_:) 函数，
让它返回一个数组，
其中包含任意两个序列共有的元素。
写 <T: Equatable> 与写 <T> ... where T: Equatable 是等价的。