清明放假，在家无聊，想写个ss来玩。
曾经用Swift子类化过Charts图表，感觉不用怎么学语法也可以勉强写写Swift，但毕竟有点蒙。
准备用NEKit，但它是Swift写的，感觉强蒙的Swift的水平搞不定。刚好Swift 5也最近发布，所以去学习了一下。
看了2天，ss是没时间写了，aha，找机会吧~
下面所有的话外点评都是我看文档时查资料写的，也有些是心声，不是原文档里的东西。
因为没有看过其它Swift文档，所以有些翻译可能和以前的翻译不一致或者错误。有些无法准确翻译的地方，我没有翻译直接放回翻译文里。在后面的读后感有写。
翻译文档地址
Swift之旅
按惯例，学新语言首先要学会写 “hello world!” ，在 Swift 里，它只需要一行代码就搞定：
print("Hello, world!")
// Prints "Hello, world!"
如果你写过 C 或者 Objective-C ，这语法你一定很熟。在 Swift 里，这行代码就是一个完整的程序了。你不需要引用类似输入/输出、或者 String 处理这样的库。任何代码都会被当做入口点，所以你不需要再手动写 main() 函数。并且句尾也可以不写分号。
话外点评:脚本语言(python、lua)既视感
本教程将会展示足够全面的信息让你能够完成不同的编程任务。不用担心看不懂教程的某部分内容——书后章节有更详细的解释说明。
注意
为了有更好的体验，请在Xcode中打开本章的playground。Playgrounds可以编辑代码，并立刻看到结果。
基本数据类型
用 let 定义常量，用 var 定义变量。虽然常量可以在编译后再被赋值，但是你必须要给它赋值一次。这意味着常量是一次赋值，多次使用。
话外点评:不理解上面这句话，找了下 stackoverflow 的定义，有人这样说：
上面这句话的意思是常量可以这样定义
let myConstant = getSomeValueFromMethod()
getSomeValueFromMethod 是需要运行后才知道的值。并不是一个编译期被知道的值。
var myVariable = 42
myVariable = 50
let myConstant = 42
常量或变量赋值必须是相同类型，但你并不总需要指明类型。常量或者变量首次赋值时，编译器将会推导出它的类型。上面的例子中，编译器推导出 myVariable 是个整型，因为42是个整型。
如果初始值无法推导类型（或者没有初始值），请在变量名后指明类型，用冒号分隔。
let implicitInteger = 70
let implicitDouble = 70.0
let explicitDouble: Double = 70
试验一下
创建一个常量，申明类型为 Float ，然后复制为4
值不会自动强转类型，如果你需要改变一个值的类型，请明确申明它的类型。
let label = "The width is "
let width = 94
let widthLabel = label + String(width)
试验一下
把上面例子最后一行的 String 拿掉，你看到报什么错？
有一种更简单的把值转成字符串的方法：把值放到圆括号里，在括号前加个反斜杠(\)
let apples = 3
let oranges = 5
let appleSummary = "I have \(apples) apples."
let fruitSummary = "I have \(apples + oranges) pieces of fruit."
试验一下
像上面一样，用
\()包含一个浮点数，然后写个 greeting 函数的人名参数组合
用3个双引号“”“可以创建多行 String 。引用内容的缩进将会被去掉，只要和结尾的引号标记同层就行。例如：
let quotation = """
I said "I have \(apples) apples."
And then I said "I have \(apples + oranges) pieces of fruit."
"""
话外点评:这里\()和String的差别是，前者要写在双引号里，后者用+号连接字符串
(""")的字符串内容的层级至少要和结尾符号齐平，不能超过左边，否则报错。
如果字符串内容带缩进，就会当成是字符串里的内容了。
用中括号创建数组和字典。访问它们的值也是用中括号写入序列号或者键。最后一个值写逗号不会报错。
var shoppingList = ["catfish", "water", "tulips"]
shoppingList[1] = "bottle of water"
var occupations = [
"Malcolm": "Captain",
"Kaylee": "Mechanic",
]
occupations["Jayne"] = "Public Relations"
当你加入元素时数组会自动增长。
shoppingList.append("blue paint")
print(shoppingList)
话外点评:这里默认就是 mutable ？似乎用 var 来修饰的东西，本身也该是 mutable ...
创建空数组或空字典，按下面这样：
let emptyArray = [String]()
let emptyDictionary = [String: Float]()
如果类型可以被推导，你可以 [] 这样写一个空数组定义，或者 [:] 这样写一个空字典定义。例如，赋值给变量，或者传递参数给函数
shoppingList = []
occupations = [:]
控制语句
if 和 switch 用做条件语句，for-in、while 和 repeat-while 做用循环。条件/循环语句里的圆括号是可选的，但包裹语句的大括号是必须的。
let individualScores = [75, 43, 103, 87, 12]
var teamScore = 0
for score in individualScores {
if score > 50 {
teamScore += 3
} else {
teamScore += 1
}
}
print(teamScore)
// Prints "11"
话外点评:深恶痛绝的单行 if bug 被语法解决了？
if 条件一定是布尔值。这样写 if score {...} 就会报错，因为 score 可能无法和0对比。
你可以把 if 和 let 绑定使用，当条件值可能为空时。这样的值被称为 optional 。一个标记为 optional 的值可以有值，也可以是 nil 。在类型后加个问号 (?) 表示这个值是 optional 的。
var optionalString: String? = "Hello"
print(optionalString == nil)
// Prints "false"
var optionalName: String? = "John Appleseed"
var greeting = "Hello!"
if let name = optionalName {
greeting = "Hello, \(name)"
}
试验一下
把上面例子的 optionalName 改为 nil 。你会得到什么样的 greeting ？再试一下，加入一个 else 语句，设置一个当 greeting 为空的输出。
如果 optional 值为 nil ，那么条件语句就为假，并跳过大括号中的代码。否则，就会自动解封装并将值赋值给 let 常量，解封装后的值可以用在这个代码主体块里使用。
另一种操作 optional 值的方法是使用 ?? 操作符。如果可选值缺省，那么就会默认值。
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.")
}
// Prints "Is it a spicy red pepper?"
试验一下
把 default 语句移除，你会得到什么错误？
注意看一下例子里 let 的匹配用法。
当 switch case 语句被匹配到，程序会离开 switch 条件。不会继续执行下面的条件，所以这里 break 也就可以省了。
你可以用 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 (kind, numbers) in interestingNumbers {
for number in numbers {
if number > largest {
largest = number
}
}
}
print(largest)
// Prints "25"
试验一下
增加一个变量，记录除了最大值外，最大值属于哪个种类的。
用 while 来重复一段代码，直到条件改变。判断条件可以放在最后，以保证至少循环1次。
话外点评:即 do-while ，只是这里把 do 换成了 repeat 。
var n = 2
while n < 100 {
n *= 2
}
print(n)
// Prints "128"
var m = 2
repeat {
m *= 2
} while m < 100
print(m)
// Prints "128"
你可以用 ..< 操作符来指定循环的序列范围。
var total = 0
for i in 0..<4 {
total += i
}
print(total)
// Prints "6"
..< 操作符是左闭右开区间，即不包括右的值。...是闭区间范围，即包括右的值。
话外点评:1 .. < 3，结果是1、2
1 ... 3， 结果是1、2、3
函数和闭包
使用 func 来定义一个函数，后面带上函数名和参数列表。后面跟 -> 表示返回值。
func greet(person: String, day: String) -> String {
return "Hello \(person), today is \(day)."
}
greet(person: "Bob", day: "Tuesday")
试验一下
删掉 day 参数。在 greeting 函数里增加一个参数，表示今天中午的特价午餐是什么。
默认情况下，函数会用参数名当做参数名的标签。你可以在参数名前加一个自定义的标签，或者增加 _ 来表示缺省。
func greet(_ person: String, on day: String) -> String {
return "Hello \(person), today is \(day)."
}
greet("John", on: "Wednesday")
使用元组来定义一个复合值——例如，用来做函数的返回值。元组的元素可以用名称或者序列号引用到。
话外点评:tuple（元组）好像是python里的叫法
元组是有序的数组型字典？
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)
// Prints "120"
print(statistics.2)
// Prints "120"
函数可以嵌套。嵌套函数可以访问外部函数中申明的变量。你可以用嵌套函数组织复杂或很长的代码。
func returnFifteen() -> Int {
var y = 10
func add() {
y += 5
}
add()
return y
}
returnFifteen()
函数是一等公民，这意味着函数可以当成返回值。
func makeIncrementer() -> ((Int) -> Int) {
func addOne(number: Int) -> Int {
return 1 + number
}
return addOne
}
var increment = makeIncrementer()
increment(7)
函数也可以被当做是一个函数的参数。
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)
函数就是一个特殊的闭包：代码块可以被任意调用。函数里的代码在闭包作用域里可以访问它的函数和变量，即使函数和闭包在不同的作用域——你刚刚已经在嵌套函数的例子里看到了。你可以用 ({}) 包含代码写一个匿名闭包。使用 in 来分开参数返回值和函数主体。
numbers.map({ (number: Int) -> Int in
let result = 3 * number
return result
})
试验一下
重写上面的闭包，将所有的奇数返回0。
你有几种更简洁的办法使用闭包。当一个闭包类型确定，像是 delegate 的返回值，你可以删除它的参数，或者它的返回值，或者两者。单个语句闭包隐式返回其唯一语句的值。
let mappedNumbers = numbers.map({ number in 3 * number })
print(mappedNumbers)
// Prints "[60, 57, 21, 36]"
你可以用序列替代名称，来引用参数。这种方法在非常短的闭包里特别好用。如果闭包做为函数的最一个传递的实参，可以在圆括号后立即出现，如果闭包是函数的唯一实参，圆括号也可以省略。
话外点评:上面这句话应该说的是尾随闭包（Trailing closure syntax）
像$0一样，是一种简写简语法，能省略参数名。
例如：
func test(arg1: Int, arg2: (Int)->(Bool)) {}
常规调用test方法时的写法是：
test(arg1: 1, arg2: ({ (a:Int) -> Bool in return a < 0 }))
解释一下：这里arg2的实参一个匿名闭包，上面说过，用({})来表示匿名闭包，用in来区分代码参数和代码主体。
按照上面提的简写法，就变成：
test(arg1: 1) { (a: Int) -> (Bool) in return a < 0}
尾随闭包写在参数括号后，省略了参数名。
let sortedNumbers = numbers.sorted { $0 > $1 }
print(sortedNumbers)
// Prints "[20, 19, 12, 7]"
话外点评:map 是一个高阶函数，用于对一个集合的所有元素做相同操作。
例如：
let values = [2.0, 4.0, 5.0, 7.0] var squares: [Double] = [] for value in values { squares.append(value * 3) }一、用 map 来表达就是：
let squares2 = values.map({ (value: Double) -> Double in return value * value })二、按照闭包唯一参数可省略圆括号的特性，变成这样：
这里value似乎可以改成任意名字？？
let squares3 = values.map { value in value * 3 }三、 更简化的做法
let squares = values.map { $0 * 3 }
对象和类
用 Class 来标识类。类里的常量和变量跟上面说的一样申明，不同的是整个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()
上面 Shape 类缺少了一个重要的东西：初始化方法。使用 Init 来创建。
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 参数。初始化参数会传递一个函数一样的数据。每个属性都需要指定值——要么在申明时，要么在初始化方法里。
用 deinit 来创建反销毁时的一些清除工作。
继承某个类用冒号分隔你类名。类可以不显示的继承任何基类。
话外点评:OC 里每个类最低限度要继承 NSObject ，这里似乎可以省略。
要重写父类方法使用 override —— 如果子类的同名方法没有写 override ，编译器会报错。同样的，子类写了override，父类却没有同名方法，编译器也会报错。
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()
试验一下
写另外一个叫 Circle 的 NamedShape 的子类，输入 radius 和 name当参数在初始化时。实现 area() 和 simpleDescriptiony 方法在 Circle 里。
除了储存简单的属性，属性还有 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)
// Prints "9.3"
triangle.perimeter = 9.9
print(triangle.sideLength)
// Prints "3.3000000000000003"
在 perimeter 里的 setter 方法，新值被隐示的命名为 newValue ,你可以在 set 后的圆括号明确给其命名。
注意初始化 EquilateralTriangle 分3步：
- 设置子类申明的属性
- 调用父类初始化
- 改变父类的属性值。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)
// Prints "10.0"
print(triangleAndSquare.triangle.sideLength)
// Prints "10.0"
triangleAndSquare.square = Square(sideLength: 50, name: "larger square")
print(triangleAndSquare.triangle.sideLength)
// Prints "50.0"
想使用 Optional 时，你可以在方法、属性、下标之前放个 ? 操作符。如果 ? 操作符前的值是空， ？ 操作符之后的代码会被忽略，且整个表达示就为 nil 。否则，Optioinal 类型被拆包，？ 后的代码会会变成拆包后的值。下面2种表达示都是 Optional 。
let optionalSquare: Square? = Square(sideLength: 2.5, name: "optional square")
let sideLength = optionalSquare?.sideLength
话外点评:什么是拆包（unwrapped）？
（网上找的）拆包其实就是一个 Optional 类型有值的时候，打印结果带有可选类型（Optional）标记，当我们去掉 Optional 类型的过程就成为拆包。
例如：Optional String 类型强制转换为 String 类型的过程，就是一种拆包过程
用自己的话来理解就是: 有值和无值封装成一个 Optional 类型值，当它有值时，就可以拆，即为拆包（unwrapped）。
枚举和结构体
用 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
试验一下
写一个方法对比2个 Rank 值
默认情况下，Swift 的 raw value 初始是0，每增加一个元素自增1，但你也可以赋值来更改它。上面的例子里， Ace 就是被赋值为1，其它名称值就会按顺序递增赋值。你同样也可以用字符串或者浮点型来给初始值赋值。rawValue 也可以用来访问枚举常量值。
用 Init?(rawValue:) 初始化方法传入 rawValue 生成一个枚举实例。如果能匹配到，它会返回对应的枚举常量实例；如果没匹配到，则返回 nil。
if let convertedRank = Rank(rawValue: 3) {
let threeDescription = convertedRank.simpleDescription()
}
枚举常量值等效于数字值，不仅仅是数字值的另外一种写法方式。实际上，如果数字值没有意思，你也没必要提供名称值。
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() 方法，为 spaders 和 clubs 返回 black，为 hearts 和 diamonds 返回 red。
注意上面例子提到的 hearts 元素值的的2个点：当为常量 hearts 赋值时，枚举 Suit.hearts 代码它的全名，因为常量没有指明类型。在 switch 里，枚举值简写成了 .hearts ，因为 Suit 知道是 self 。你可以在任何已经类型下用这种简写法。
如果枚举有数字值，这些值就被看做一部分的申明，意味着所有实例有同样的值。另外一种用枚举的方法是用值来绑定名称——这些值在你创建实例实被决定，而且它们每个都同。你可以想象成绑定值和实例一样。例如，从服务器请求日出和日落的时间。服务器即需要返回请求的信息数字，也需要返回出错时的信息。
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)")
}
// Prints "Sunrise is at 6:00 am and sunset is at 8:09 pm."
试验一下
增加第3种枚举元素 ServerResponse 到 swtich 里。
注意日出和日落是如何从 ServerReponse 里的值分离到条件语句里的。
用 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()
试验一下
写一个函数，包含一个完整的卡片组，每个组合等级卡片都有一张。
======我是分隔线=======
话外点评:枚举、结构体、类，3种感觉都很像。都是面向对象型的东西。
但枚举和结构体是值类型，类是引用类型。
它们的对象，只有类的实例才叫对象，枚举和结构体的只叫实例。
协义和扩展
用 protocol 来定义一个协议。
protocol ExampleProtocol {
var simpleDescription: String { get }
mutating func adjust()
}
话外点评:默认情况下值类型的枚举、结构体里的变量都是不可以更改的，只有引用类型的类是可以变的。用mutating来修饰之后，就可以达到可以更改的效果？
有点java里抽象方法的意味...
类、枚举、结构体都可以采用协义。
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 并不需要这样的标记，因为它本身可以更改。
用 extension 向现有类型添加功能，例如新方法和属性。你可以用 extension 给其它地方申明的类型做扩展，甚至于其它引入的库或者框架。
extension Int: ExampleProtocol {
var simpleDescription: String {
return "The number \(self)"
}
mutating func adjust() {
self += 42
}
}
print(7.simpleDescription)
// Prints "The number 7"
试验一下
用扩展给 Double 增加一个 absoluteValue 方法。
你可以使用协议名像其它类型名一样——例如，创建一组不同类型的集合，但是都遵循同一个协议。当你用协议名做类型时，它们使用的都是同一个协议已定义的东西，协议之外的方法就不可用了。
let protocolValue: ExampleProtocol = a
print(protocolValue.simpleDescription)
// Prints "A very simple class. Now 100% adjusted."
// print(protocolValue.anotherProperty) // Uncomment to see the error
虽然这里 protocolValue 看起来是 SimpleClass 类型，但是编译器把它当成是 ExampleProtocol 类型。这就意味着你不可能访问到除了协议外定义到的方法。
错误处理
你所有的错误类型都要遵循 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 代码块里，你在前面写个try 来标记代码可以抛出错误。在 catch 代码块里，错误会自动命名为 error ，除非你指定了别的名称。
do {
let printerResponse = try send(job: 1040, toPrinter: "Bi Sheng")
print(printerResponse)
} catch {
print(error)
}
// Prints "Job sent"
试验一下
改变打印的名称改为 “Never Has Toner” ，以便抛出异常。
你可以提供多个 catch 代码块处理某种指定的错误。在 catch 代码块后面按照 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)
}
// Prints "Job sent"
试验一下
给 do 代码块里添加代码，以便抛出异常。什么类型的错误可以去到 catch 后的第1个代码块里？第2和第3代码块又如何去呢？
另外一种错误处理的方法是用 try? 将结果转换成可选值。如果函数抛出错误，这个错误会被抛弃，然后结果返回空。反之，函数返回一个 optional 的有值的常量。
let printerSuccess = try? send(job: 1884, toPrinter: "Mergenthaler")
let printerFailure = try? send(job: 1885, toPrinter: "Never Has Toner")
使用 defer 可以执行函数所有代码执行完后的代码块。这段代码无论是不是有错误处理。你可以把setup 和 cleanup 的代码的 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)
// Prints "false"
话外点评:这里的 defer 是 OC 里的 Finally ？
泛型
用尖括号包含名称的方式来写一个泛型方法或者类型。
func makeArray- (repeating item: Item, numberOfTimes: Int) -> [Item] {
var result = [Item]()
for _ in 0..
generic 可以用在函数、方法、类、枚举、结构体里。
// Reimplement the Swift standard library's optional type
enum OptionalValue {
case none
case some(Wrapped)
}
var possibleInteger: OptionalValue = .none
possibleInteger = .some(100)
在函数体之前用 where 来指定必须协议——例如，要求实现某个协议、要求2个类型相同、或者某个类有超类。
func anyCommonElements(_ 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(::) 函数，让它返回2个序列参数中共有元素的数组。
这里
读后感
- 函数的参数名扩展有意思！命名的好，调用起来更容易看得懂了，不用再进到定义里了。
- optional、raw value、case value、不知道怎么翻译？
- switch-case为什么条件不仅限于常量，为什么可以省略break了？
- 为什么有时候叫 Method 有时候叫 Function ，存在2种叫法？似乎把面向函数，面向对象分得很清。。
- 为什么要有 类、枚举、结构体 3种东西？
- 泛型似乎很强大...