原文 A Swift Tour

初见Swift

通常来说，学习新语言的第一个应用程序都会是在屏幕上输出"Hello, world"这么一句话。在Swift，可以用一行代码完成：

print("Hello, world!")

如果你写个C或者Objective-C的代码，那你应该熟悉这种语法——在Swift中，这行代码就是一个完整程序。你不需要为了类似输入/输出或者字符串处理等功能单独导入一个库。全局作用域的代码会被自动当做程序入口点，所以你不需要一个main()函数。你也不需要在每条语句结尾写上分好，

这个教程通过完成一系列编程任务来让你初步了解开始Swift编程相关的信息。如果你有不理解的地方也不要担心——任何本章结束的内容都会在后续章节都有详细讲解。

通知：
为了最好的的体验，在Xcode中使用playground功能。Playground可以让你在编辑代码时实时查看运行结果
Download Playground

简单值

使用let来声明常量，使用var来声明变量。一个常量的值在编译时并不需要获取，但是你只能为它赋值一次。也就是说你可以用常量来表示这样一个值：你只需要决定一次，但是需要使用很多次。

var myVariable = 42
myVariable = 50
let myConstant = 42

常量或变量的类型必须和你要赋给它的值的类型相同。然而，你并不总是需要明确指明类型。声明一个变量或者常量的同时赋值，编译器会自动推断它的类型。上面例子中，编译器推断myVariable是一个整数(Interget)，因为它的初始值是整数。

如果初始值没有提供足够的信息(或者没有初始值)，那可以在变量后面生命类型，并用冒号分割。

let implicitInteger = 70
let implicitDouble = 70.0
// 指定常量或者变量类型
let explicitDouble: Double = 70

```

>实践
创建一个常量，并指定类型Float，然后复制4
```
let experiment: 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."
```
>实践
使用```\()```来把一个浮点计算转换成字符串，并加上某人的名字，然后和他打个招呼。
```
let apples = 3.0
let oranges = 5.0
let name = "Johnny"
let stirng = "Hi,\(name), i have \(apples + oranges) pieces of fruit,would you like to try it"
```

使用```[]```来创建数组和字典，然后通过下标或者键值来访问元素。在最后一个元素之后允许加上逗号```,```。
```
var shoppingList = ["catfish", "water", "tulips", "blue paint"]
shoppingList[1] = "bottle of water"
var occupations = [
"Malcolm": "Captain",
"Kaylee": "Mechanic",
]
occupations["Jayne"] = "Public Relations"
```
使用初始化语法创建一个空的数组或字典
```
let emptyArray = [String]()
let emptyDictionary = [String: Float]()
```
如果类型是可以被推断出来的，你可以使用```[]```创建空数组和使用```[:]```创建空字典——就像你为变量赋值新值或者给函数传参的时候一样
```
shoppingList = []
occupations = [:]
```

##控制流
使用```if```和```switch```进行条件操作，使用```for-in```, ```for```, ```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)
```
在```if```语句中，条件的值必须是```Boolean```表达式——这就意味着类似```if score{...}```语句是错误的，而不会隐性的与0作比较。

你可以同时使用```if```和```let```处理值缺失的情况。这些值表示为可选的。可选的值可能是一个具体的值或者是```nil```以表示值得缺失。在类型后面加一个```?```来标记变量的值是可选的。

```
var optionalString: String? = "Hello"
print(optionalString == nil)
var optionalName: String? = "John Appleseed"
var greeting = "Hello!"
if let name = optionalName {
  greeting = "Hello, \(name)"
}
```
>实践
把optionalName改成nil，greeting会是什么？添加一个else语句，当optionalName是nil时给greeting赋一个不同的值
```
if let name = optionalName {
    greeting = "Hello, \(name)"
} else {
    greeting = "can not be nil"
}
```

如果变量的可选值是```nil```，条件会判断为```false```，大括号中的代码会被跳过。如果不是```nil```，会将值赋给```let```后面的常量，这样代码块中就可以使用这个值了。

处理可选变量的另一种方式是使用```??```操作提供一个默认值。如果可选变量的值缺失，可以使用默认值来代替。
```
let nickName: String? = nil
let fullName: String = "John Appleseed"
let informalGreeting = "Hi \(nickName ?? fullName)"
```

Switches2支持任何数据类型以及各种比较操作——不仅仅是整数以及测试相等。(PS:case除了用于判断值相等之外，也可以添加自己的用于判断的表达式，比如例子中的 ``` case let x where x.hasSuffix("pepper")```)
```
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.")
}

```
>实践
删除default语句，看看会有什么错误

注意"let" 在上述例子的等式中是如何使用的，它将匹配等式的值赋给常量 x。
执行了```switch```中的匹配的```case```代码后，程序会推出```switch```语句，而不会继续执行下一条```case```语句，因此不需要在每条```case```语句后面写上```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)
```
>实践
添加另一个变量来跟踪最大数值对应的种类，并且记录最大的数值。

使用```while```语句来重复运行一段代码知道条件不满足。循环条件也可以写在结尾，而且必须确保能至少执行一次循环。
```
var n = 2
while n < 100 {
    n *= 2
}
print(n)

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

你可以在循环语句中使用```..<```表示索引范围。
```
var total = 0
for i in 0..<4 {
    total += i
}
print(total)
```
使用```..<```表示的范围不包含上限，如果需要包含的话可以使用```...```。
(PS: ```0..<4```相当于 ```x >= 0 && x < 4```  ```0...4```相当于```x >=0 && x <= 4```)


##函数和闭包
使用```func```语句声明一个函数。通过名称和参数列表调用函数。在参数名称和类型之后使用```->```来指定返回值的类型。
```
func greet(person: String, day: String) -> String {
    return "Hello \(person), today is \(day)."
}
print(greet(person: "Bob", day: "Tuesday"))
```

>实践
删除```day```这个参数。在问候语中添加一个参数表示今天吃的什么午饭。

默认情况下，函数使用它们的参数名称作为它们参数的标签，在参数名称前可以自定义参数标签，或者使用 _ 表示不使用参数标签。
```
func greet(_ person: String, on day: String) -> String {

return "Hello \(person), today is \(day)."

}

greet("John", on: "Wednesday")
```
使用元组来生成复合值——例如从函数返回多个值。元组的元素可以用名称或数字来表示。
```
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)
print(statistics.2)
```
函数可以带有可变个数的参数，这些参数以数组形式表现。
```
func sumOf(numbers: Int...) -> Int {
    var sum = 0
    for number in numbers {
        sum += number
    }
    return sum
}
sumOf()
sumOf(numbers: 42, 597, 12)
```
>实践
写一个计算品均值的函数

```
func avg(numbers: Int...) ->Float {
    var sum = 0
    for number in numbers {
        sum += number
    }
    return (Float(sum) / Float(numbers.count))
}
print(avg(numbers: 1,2,3,4))
```
函数可以嵌套。嵌套函数可以访问外层函数声明的变量。你可以使用嵌套函数重构一个太长或者太复杂的函数。
```
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 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]
print(hasAnyMatches(list: numbers, condition: lessThanTen))
```
函数实际上是一种特殊的闭包：是一种延后调用的代码块。闭包中的代码能访问声明此闭包所在作用域范围内的可用的函数和变量，即使闭包在其他作用域内执行——你以及在嵌套函数的例子中见到过。你可以使用```({})```声明一个匿名闭包。使用```in```将闭包函数体与参数和返回值进行分离
```
numbers.map({ (number: Int) -> Int in
    let result = 3 * number
    return result
})
```

>实践
重写闭包，对所有奇数返回0

```
print(numbers.map({ (number: Int) -> Int in
    let remainder = number % 2
    if remainder != 0 {
        return 0
    }
    return number
}))
```
你有多种创建更简洁闭包的方法。当一个闭包类型已经明确时，比如作为一个代理的回调，你可以忽略其参数，返回值，或者都忽略。单个语句的闭包会把语句的值当做结果返回。
```
let mappedNumbers = numbers.map({ number in 3 * number })
print(mappedNumbers)
```
你可以通过参数索引(number)而不是参数名字应用参数——这个方法在非常简短的闭包中非常有用。当一个闭包作为最后一个参数传给一个函数的时候，它可以直接跟在括号后面。当一个闭包是传给函数的唯一参数，你可以完全忽略括号。

```
let sortedNumbers = numbers.sorted { $0 > $1 }
print(sortedNumbers)
```

##对象和类
使用```class```并在后面加上类名的方式创建一个类。类中的属性声明和声明变量、常量一样，唯一的区别就是属性在类的上下文(context)中。同样，方法和函数声明也一样。
```
class Shape {
    var numberOfSides = 0
    func simpleDescription() -> String {
        return "A shape with \(numberOfSides) sides."
    }
}
```

>实践
使用```let```添加一个常量属性，再添加一个接受一个参数的方法

在类名后加上```()```来创建类的实例。使用点语法访问实例的属性和方法。

```
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```。当你创建类实例时，像传入函数参数一样给构造器传入参数。每一个属性都需要赋值——可以在其声明时(就行```numberOfSides```)或者在构造器中(就行```name```)

如果你需要在对象被释放前做一些清理工作，使用```deinit```创建一个析构器。
子类的定义是在子类名称后面加上父类名称，用冒号隔开。创建子类的时候并不需要任何标准的根类(PS:这句翻译有待调整)，所以你可以根据需要添加或者忽略父类。
子类可以通过```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()
```
>实践
创建另一个```NamedShape```的子类，命名为```Circle```，并且在构造器中添加```name```和```radius```的两个参数。在```Circle```中实现```area()```和```simpleDescription()```两个方法。

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

let circle = Circle(radius: 2, name: "Circle")
circle.area()
circle.simpleDescription()
```

属性除了简单存储外，还可以有```setter```和```getter```
```
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)
```

在```perimeter```的setter方法中，新值的名字是```newValue```。你可以在```set```之后显示的设置一个名字。

注意```EquilateralTriangle```类的构造器执行了三步:
1、给子类属性赋值
2、调用父类构造器
3、改变父类声明的属性值。其他工作比如调用方法、getters和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```。否则，这个可选变量值是unwrapped的，并且```?```后面的行为都是unwrapped的。在这两种情况下，整个表达式的值都是```optional```
  
```
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 ace = Rank.ace
let aceRawValue = ace.rawValue
```

>实践
写一个函数，通过比较原始值来比较两个```Rank```。

默认情况下，Swift是按照从0开始并且每次加1的方式给原始值赋值，不过你也可以通过直接指定值得方式来改变这种行为。在上面的例子中，```ace```被直接赋值为```1```，并且其余的原始值按顺序赋值。你也可以使用字符串或者浮点数作为枚举的原始值类型。使用```rawValue```属性访问枚举的原始值。

使用```init?(rawValue:)```初始化构造器生成一个带有原始值的枚举成员。如果存在跟原始值匹配的枚举成员返回该枚举成员，否则返回```nil```。
```
if (let convertedRank = Rank(rawValue: 3)) {
    let threeDescription = convertedRank.simpleDescription()
}
```
枚举中```case```的值是实际值，并不是原始值的另一种表达方式。实际上，如果没有一个有意义的原始值，你就不需要提供原始值。
```
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() 方法，对 spades 和 clubs 返回 “black” ，对 hearts 和 diamonds 返回 “red” 。

```
func color() -> String{
    switch self {
    case .spades, .clubs:
        return "black"
    case .diamonds, .hearts:
        return "red"
    }
}
```

注意上面例子中用了两种方式引用枚举成员```hearts```：当给```hearts```常量赋值时，引用枚举成员需要使用全名```Suit.hearts```，因为常量没有明确指定类型。在```switch```内部，引用枚举成员只需要使用缩写```.hearts```，因为已经知道```self```是```suit```类型。在已知变量类型的情况下可以使用缩写。

如果枚举有原始值，那这些值在声明时就被决定了，那就特定枚举成员实例总是具有相同的原始值。枚举成员使用的另一种方案是设置关联值——这些值是在创建实例时决定的，并且可针对不同的枚举实例的成员的值是可以不同的。你可以把关联词想象成枚举实例的存储属性。比如，考虑从服务器获取日出和日落的时间。服务器要么返回请求信息，要么返回错误描述。
```
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 failure {
    case let .result(sunrise, sunset):
        print("Sunrise is at \(sunrise) and sunset is at \(sunset).")
    case let .failure(message):
        print("Failure...  \(message)")
}
``` 

>实践
给 ```ServerResponse``` 和 ```switch``` 添加第三种情况。

注意日出和日落实践是如何从```ServerResponse```中提取到```switch/case```中作为匹配值的一部分。

使用```struce```创建一个结构体。结构体和类有许多相同的地方，包括方法和构造器。类和结构体最大的不同是结构体总是采用复制的方式传值，而类是采用引用的方式。
```
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()
```

>实践
给 Card 添加一个方法，创建一副完整的扑克牌并把每张牌的 rank 和 suit 对应起来。

##协议和扩展

使用```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
```

>实践
写一个实现这个协议的枚举。

```
enum SimpleEnumeration: ExampleProtocol {
    case first(String)
    var simpleDescription: String {
        get {
            switch self {
                case let .first(string):
                    return string
            }
        }
    }
    mutating func adjust() {
        switch self {
            case let .first(string):
                self = .first("Hi, \(string)")
        }
    }
}
var e = SimpleEnumeration.first("Johnny")
print(e.simpleDescription)
e.adjust()
print(e.simpleDescription)
```
注意声明```SimpleStructure```时候使用```mutating```关键字标记这是一个会修改结构体的方法。```SimpleClass```声明时任何方法都不需要使用```mutating```标记，因为类中的方法总是可以修改类。

使用```extension```来为现有的类型添加功能，比如新的方法和computed properties。你可以使用扩展让某个在别处声明的类型来遵守某个协议，这同样适用于从外部库或者框架引入的类型。
```
extension Int: ExampleProtocol {
    var simpleDescription: String {
        return "The number \(self)"
    }
    mutating func adjust() {
        self += 42
    }
 }
print(7.simpleDescription)
```

>实践
给 Double 类型写一个扩展，添加 absoluteValue 功能。

```
extension Double {
    //extension中只能添加Couputed properties，不能直接添加Stored properties;
    //如果需要添加Stored properties需要通过Runtime的objc_getAssociatedObject和objc_setAssociatedObject的方式实现
    var absoluteValue:Double {
        return abs(self)
    }
}
let absolute: Double = -11.2
print(absolute.absoluteValue)
```
你可以像使用其它命名类型一样使用协议名——例如，创建一个有不同类型但是都实现一个协议的对象集合。当你处理一个协议类型的值时，协议外声明的方法是不可用的。
```
let protocolValue: ExampleProtocol = a
print(protocolValue.simpleDescription)
// print(protocolValue.anotherProperty)  // anotherProperty是SimpleClass属性，注释后查看错误提示
```
即使```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)

}

>实践
将 printer name 改为 "Never Has Toner" 使 send(job:toPrinter:) 函数抛出错误。

你可以使用多个```catch```代码块处理特定的错误。你可以参照```switch```中的```case```来写```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)
}
```

>实践
在 do 代码块中添加抛出错误的代码。你需要抛出哪种错误来使第一个 catch 块进行处理？怎么使第二个和第三个 catch 进行处理呢？

另一个处理错误的方式是使用```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)
```

##泛型
在尖括号里写上名称来创建一个泛型函数或者类型。
```
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)
```
你可以创建泛型函数、方法、类、枚举和结构体

```
// Reimplement the Swift standard library's optional type
enum OptionalValue<Wrapped> {
    case none
    case some(Wrapped)
}
var possibleInteger: OptionalValue<Int> = .none
possibleInteger = .some(100)
```
在语句体前面使用 ```where``` 来指定对类型的需求——比如，限定类型实现某一个协议，限定两个类型是相同的，或者限定某个类必须有一个特定的父类。
```
func anyCommonElements<T: Sequence, U: Sequence>(_ lhs: T, _ rhs: U) -> Bool
    where T.Iterator.Element: Equatable, T.Iterator.Element == U.Iterator.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``` 的写法是等价的。