关于Swift

Swift是一个非常棒的开发工具，无论是用于手机、台式机、服务器或者其他任何运行代码的平台。它将现代编程语言的精髓和Apple工程文化与开源社区的大力贡献结合起来，成为一种安全、迅速、交互式的编程语言。编译器优化性能，语言优化开发方式，两者互不干扰。

对于刚开始学习编程的人来说，Swift是非常友好的。它是一个既满足工业标准又像脚本语言一样充满表现力和趣味的编程语言。在playground中书写Swift代码，无需构建和运行应用程序就能看到代码的运行结果。

Swift按照现代编程模式定义了一些常见的编程错误:

• 变量应该先初始化再使用
• 检查数组索引是否越界
• 检查整数是否溢出
• Optional要处理值为nil的情况
• 自动管理内存
• 意外故障可以通过抛出错误进行处理

Swift充分利用硬件设施来编译和优化代码，基于代码清晰明了且运行性能最佳的原则来设计语法和标准库，它将安全和速度相结合，使得Swift成为从"Hello world"到整个操作系统的最佳选择。

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

多年来Swift随着新特性和功能的出现不断在发展。我们对Swift寄予了很大的期望，迫不及待的想看看你用它创造出来的奇迹。

版本兼容性

本书描述了Swift4.2，也就是Xcode 10.0中Swift的默认版本。你可以使用Xcode 10.0构建Swift 4或者Swift 3的项目。
注意
当使用Swift 4.2的编译器编译Swift 3的代码时，它会将其语言版本标识为3.4。因此，你可以使用#if swift(>=3.4)这样的条件编译块来编写版本兼容的代码。

当使用Xcode 9.2来构建Swift 3的代码时，Swift 4中的大多数功能都是可用的。需要注意的是，下面的功能仅能在Swift 4中使用:

• Substring的相关操作将返回Substring类型的实例，而不是String。
• 隐式@objc的自动推断仅会添加在很少的地方。
• 同一文件中类扩展可以访问该类的私有成员。

Swift 4编写的项目可以依赖Swift 3编写的项目，反之亦然。这意味着如果你有一个被划分为多个框架的大型项目，你可以逐一将框架从Swift 3迁移到Swift 4。

Swift教程

一般来说新语言中第一个项目应该是在屏幕上打印"Hello world"。在Swift中，一行代码就可以实现:

print("Hello world!")

如果你写过C或Objective-C代码，这种语法对你来说应该很熟悉，在Swift中，这行代码就是一个完整的程序。你不需要为输入/输出或字符串处理等功能导入单独的库。在全局作用域编写的代码被用做程序的入口，因此不需要写main()函数。也不需要在每个语句的末尾写分号。

本教程通过演示如何完成各种编程任务，来让你对Swift有足够的了解并可以开始书写Swift代码。如果有什么地方不明白不要担心，这本书的其余部分将会详细解释本教程中介绍的所有内容。
注意
本章内容最好在Xcode的playground中练习，因为playground可以在编辑代码的同时看到运行结果。

简单值

使用let创建常量，使用var创建变量。编译时不需要知道常量的值，但是必须要为常量赋值一次。也就是说你可以使用常量来命名一个值，一次赋值就可在多个地方使用。

var myVariable = 42
myVariable = 50
let myConstant = 42

常量或者变量赋值时类型必须要与声明类型相同。不用总在声明时指定类型，可以在创建常量或变量时设置初始值让编译器自动推断其类型。在上面的例子中，myVariable的初始值是整数，所以编译器会认为myVariable是整数类型。

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

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

练习
创建一个显式浮点类型值为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 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.
    """

使用方括号([])来创建数组和字典，通过在方括号中写入索引或键来访问元素。可以在最后一个元素后面加逗号。

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)

如果想要创建空数组或字典，请使用构造函数。

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语句中，条件必须是布尔表达式，这就意味着if score {...}这样写是错误的，这并不会与0做隐式比较。

你可以用if和let来处理可能为nil的值，这些值用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将会变成什么? 如果optionalName是nil，加一个else来设置一个不同的greeting。

如果Optional的值为nil，则条件为false，并跳过大括号中的代码。否则，Optional的值将会被解析然后赋值给let之后的常量，这样就可以在代码块中使用解析后的值。

另一种处理Optional值的方法是使用??操作符。如果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将匹配的值赋值给常量x。

在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来执行循环代码，直到条件发生改变。循环的条件可以写在末尾，以确保循环至少运行一次。

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"

使用..<表示不包含范围右边最大值的取值。使用...表示包含范围两边的取值。

函数和闭包

使用func来声明函数。通过在函数名后面加上圆括号以及括号的参数列表来调用函数。使用->将参数的名称和类型与函数的返回值区分开来。

func greet(person: String, day: String) -> String {
    return "Hello \(person), today is \(day)."
}
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)
// 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的闭包。

闭包有几种简单的定义方式。当已知闭包类型时(比如委托回调)，就可以省略其参数类型或返回值类型，或两者都省略。单个语句的闭包默认返回其唯一表达式的值。

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

在短闭包中可以使用下标来引用参数。作为函数最后一个参数的闭包可以直接在括号后面书写，当闭包是函数的唯一一个参数时，括号可以省略。

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

对象和类

使用class和类名来创建类。类中属性的声明与常量、变量的声明相同，唯一的区别就是将它写在类中而已。同样，方法和函数声明也一样。

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创建一个析构器。

可以通过在子类类名和父类类名之间用冒号分隔的方法来创建子类。创建类的时候不需要有一个标准的根类，所以可以根据需要包含或者省略父类。

子类重写父类的方法时要写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类。该类的构造函数有两个参数:radiu和name，并且实现area()和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)
// Prints "9.3"
triangle.perimeter = 9.9
print(triangle.sideLength)
// Prints "3.3000000000000003"

在属性perimeter的setter方法中，新值默认名称为newValue，也可以在set之后的括号里指定新值的名称。

请注意类EquilateralTriangle的初始化有三步:
1. 设置子类声明的属性值。
2. 调用父类的构造函数。
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，?之后的值都将会被忽略，且整个表达式的返回值为nil。反之，将会解析Optional的值，?之后的表达式将会作用在被解析的值上。这两种情况下，整个表达式的值都是一个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

练习
写一个通过比较原始值来排序的函数。

默认情况下，Swift的原始值从0开始，按顺序依次递增1，不过也可以显式的指定原始值。在上例中，ace的原始值就被显式的赋值为1。其余的原始值按顺序依次递增。你也可以使用字符串或浮点型数据作为枚举的原始值。使用rawValue属性访问枚举的原始值。

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

练习
添加一个color()方法，使spades和clubs返回black，hearts和diamonds返回red。

上面用了两种方式引用了枚举值hearts:给常量hearts赋值时，由于该常量没有显示的指定类型，所以需要用全名Suit.hearts来引用。在switch中，因为已知self是Suit类型，所以可以用.hearts这种缩写形式来引用。也就是说，只要值的类型已知，那么就可以使用缩写形式。

如果枚举值有原始值，那么这些原始值在声明的时候就已经确定了。这意味着对于同一种类型的枚举器，其实例的原始值总是相同的。当然也可以为枚举值设置关联值，这些值是在创建实例时传入的，此时，同一种类型的枚举器，其实例的原始值就是不同的。你也可以认为关联值其实就是枚举值的属性。例如，从服务端请求日出和日落时间时，服务端将会响应该请求或者返回错误信息。

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."

练习
给ServerResponse再添加一个枚举值。

注意日出和日落时间是如何从ServerResponse中提取到并与switch的case相匹配的。

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

练习
编写一个函数，该函数的返回值为一副完整的纸牌，并且每张牌的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

练习
向ExampleProtocol中添加另一个方法，如何修改SimpleClass和SimpleStructure才能使它们仍能遵守该协议?

注意SimpleStructure的声明中使用关键字mutating来表示可以在该方法中修改结构体(注:枚举变量也需要加mutating关键字)。而在SimpleClass中不需要写mutating，因为在类中可以随意的修改自己的成员变量和方法。

使用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类型的。这也就是说除了协议中定义的方法，protocolValue无法访问SimpleClass类的方法或属性。

错误处理

任何遵守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来标记可能会抛出错误的代码。除非自行指定错误名称，否则错误名称默认为error。

do {
    let printerResponse = try send(job: 1040, toPrinter: "Bi Sheng")
    print(printerResponse)
} catch {
    print(error)
}
// Prints "Job sent"

练习
将printerName改为Never Has Toner，send(job:toPrinter:)就会抛出错误。

也可以使用多个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块中捕获，需要抛出什么类型的错误?如果要在第二个或第三个catch块中捕获呢?

另一种处理错误的方法是使用try?将结果转为Optional类型。如果函数抛出了错误，该错误会被抛弃并且返回值为nil。否则，返回值为Optional类型。

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

可以使用defer来保存需要在函数其他代码执行之后、return执行之前执行的代码。无论函数是否抛出错误，defer中代码的都会执行。也可以使用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"

泛型

在尖括号内写一个名字来创建一个泛型函数或泛型类型。

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)

泛型也可以用于函数、方法、类、枚举和结构体。

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.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这两种写法是等价的。