创建常量(constants)和变量(variables)

Swift 可以创建常量和变量，但通常更倾向于创建常量。

用它来创建和更改变量字符串：

var name = "Ted"
name = "Rebecca"

如果不想改变数值，可以使用常量来代替：

let user = "Daphne"

print() 函数有助于学习和调试，并能显示变量的一些信息：

print(user)

字符串 (Strings)

Swift 字符串以双引号开始和结束：

let actor = "Tom Cruise"

它们与表情符号也配合得很好：

let actor = "Tom Cruise 🏃‍♂️"

如果你希望在字符串中使用双引号，请在它们前面放置一个反斜杠：

let quote = "He tapped a sign saying \"Believe\" and walked away."

如果你想要一个跨越多行的字符串，请以三个双引号开头和结尾，如下所示：

let movie = """
A day in
the life of an
Apple engineer
"""

Swift为字符串提供了许多有用的属性和方法，包括**.count**来读取它有多少个字母：

print(actor.count)

还有**hasPrefix()和hasSuffix()**让我们知道字符串是以特定字母开头还是结尾：

print(quote.hasPrefix("He"))
print(quote.hasSuffix("Away."))

**提示：**在Swift中，字符串区分大小写，因此第二次检查将返回false。

整数 (Int)

Swift使用**Int**类型存储整数，该类型支持一系列标准数学运算符：

let score = 10
let higherScore = score + 10
let halvedScore = score / 2

它还支持修改原位变量的复合赋值运算符：

var counter = 10
counter += 5

整数自己具有一些有用的功能，例如**isMultiple(of:)**方法：

let number = 120
print(number.isMultiple(of: 3))

你还可以在特定范围内生成随机整数，如下：

let id = Int.random(in: 1...1000)

小数 (Decimals)

如果你创建一个具有小数点的数字，Swift会将其视为**Double**：

let score = 3.0

Swift认为**Double是与Int**完全不同的数据类型，不会让你将它们混合在一起。

布尔值 (Booleans)

Swift使用**Bool**类型来存储真或假：

let goodDogs = true
let gameOver = false

你可以通过调用其**toggle()**方法将布尔值从true翻转到false：

var isSaved = false
isSaved.toggle()

连接字符串

你可以使用字符串插值从其他数据中创建字符串：在字符串中写一个反斜杠，然后将变量或常量的名称放在括号中，如下所示：

let name = "Taylor"
let age = 26
let message = "I'm \(name) and I'm \(age) years old."
print(message)

当该代码运行时，它会打印“I’m Taylor and I’m 26 years old.”

数组 (Arrays)

你可以将项目分组到这样的数组中：

var colors = ["Red", "Green", "Blue"]
let numbers = [4, 8, 15, 16]
var readings = [0.1, 0.5, 0.8]

每一个都包含不同类型的数据：一个字符串、一个整数和一个小数。当我们从数组中读取数据时，我们将得到适当的类型-String、Int或Double：

print(colors[0])
print(readings[2])

**提示：**确保项目存在于你请求的索引中，否则您的代码将崩溃——你的应用程序将停止工作。

如果你的数组是可变的，您可以使用**append()**添加新项目：

colors.append("Tartan")

你添加的数据类型必须与已经存在的数据类型相匹配。

数组具有有用的功能，例如**.count来读取数组中有多少个项目，或者remove(at:)**来删除特定索引中的一个项目：

colors.remove(at: 0)
print(colors.count)

你可以使用**contains()**来检查数组是否包含特定项目，如下所在：

print(colors.contains("Octarine"))

字典 (Dictionaries)

字典根据我们指定的键存储多个值。例如，我们可以创建一个字典来存储有关一个人的信息：

let employee = [
    "name": "Taylor",
    "job": "Singer"
]

要从字典中读取数据，请使用创建时使用的相同键：

print(employee["name", default: "Unknown"])
print(employee["job", default: "Unknown"])

如果我们请求的密钥不存在，将使用**default**值。

集合 (Sets)

集合类似于数组，只是你不能添加重复的项目，而且它们不会按照特定顺序存储项目。

这就成了一组数字：

var numbers = Set([1, 1, 3, 5, 7])
print(numbers)

请记住，该集合将忽略重复值，并且不会记住数组中使用的顺序。

将项目添加到集合中是通过调用其**insert()**方法完成的，如下所示：

numbers.insert(10)

与数组相比，集合有一个很大的优势：在集合上使用**contains()**实际上是即时的，无论集合包含多少项——即使是包含10,000,000项的集合也会立即响应。

枚举 (Enums)

枚举是一组命名值，我们可以创建并使用它来使我们的代码更高效、更安全。例如，我们可以像这样对工作日进行枚举：

enum Weekday {
    case monday, tuesday, wednesday, thursday, friday
}

这称为新的枚举**Weekday**，并提供五个案例来处理五个工作日。

我们现在可以制作该枚举的实例，然后为其分配其他可能的案例：

var day = Weekday.monday
day = .friday

类型注释 (Type annotations)

你可以通过使用如下类型注释来尝试为新变量或常量强制特定类型：

var score: Double = 0

如果没有**: Double部分，Swift会推断这是一个Int，但我们覆盖了它，并说它是一个Double**。

以下是一些基于迄今为止涵盖的类型的类型注释：

let player: String = "Roy"
var luckyNumber: Int = 13
let pi: Double = 3.141
var isEnabled: Bool = true
var albums: Array<String> = ["Red", "Fearless"]
var user: Dictionary<String, String> = ["id": "@twostraws"]
var books: Set<String> = Set(["The Bluest Eye", "Foundation"])

数组和字典非常普遍，它们具有更易于编写的特殊语法：

var albums: [String] = ["Red", "Fearless"]
var user: [String: String] = ["id": "@twostraws"]

知道确切的事物类型对于创建空集合很重要。例如，两者都创建空字符串数组：

var teams: [String] = [String]()
var clues = [String]()

枚举的值与枚举本身的类型相同，因此我们可以这样写：

enum UIStyle {
    case light, dark, system
}

var style: UIStyle = .light

条件 (Conditions)

使用**if、else和else if**语句来检查条件并酌情运行一些代码：

let age = 16

if age < 12 {
    print("You can't vote")
} else if age < 18 {
    print("You can vote soon.")
} else {
    print("You can vote now.")
}

我们可以使用**&&**来组合两个条件，只有当里面的两个部分为真时，整个条件才会为真：

let temp = 26

if temp > 20 && temp < 30 {
    print("It's a nice day.")
}

或者，如果任一子条件为真，**||**将使条件为真。

switch语句

Swift允许我们使用**switch/case**语法根据多个条件检查值，如下所示：

enum Weather {
    case sun, rain, wind
}

let forecast = Weather.sun

switch forecast {
case .sun:
    print("A nice day.")
case .rain:
    print("Pack an umbrella.")
default:
    print("Should be okay.")
}

**switch**语句必须详尽无遗：必须处理所有可能的值，这样你就不会意外错过一个。

三元条件运算符 (The ternary conditional operator)

三元运算符允许我们检查一个条件并返回两个值之一：如果条件为真，则返回一个值，如果条件为假，则返回第二个值：

let age = 18
let canVote = age >= 18 ? "Yes" : "No"

当该代码运行时，**canVote将设置为“是”，因为age**设置为18岁。

循环 (Loops)

Swift的**for**循环为集合或自定义范围内的每个项目运行一些代码。例如：

let platforms = ["iOS", "macOS", "tvOS", "watchOS"]

for os in platforms {
    print("Swift works on \(os).")
}

你还可以循环一系列数字：

for i in 1...12 {
    print("5 x \(i) is \(5 * i)")
}

**1...12包含1到12（含）的值。如果您想排除最终数字，请使用..<**代替：

for i in 1..<13 {
    print("5 x \(i) is \(5 * i)")
}

提示：如果你不需要循环变量，请使用_：

var lyric = "Haters gonna"

for _ in 1...5 {
    lyric += " hate"
}

print(lyric)

还有**while**循环，执行循环主体，直到条件为false，如下：

var count = 10

while count > 0 {
    print("\(count)…")
    count -= 1
}

print("Go!")

你可以使用**continue**”跳过当前循环迭代，然后继续执行以下操作：

let files = ["me.jpg", "work.txt", "sophie.jpg"]

for file in files {
    if file.hasSuffix(".jpg") == false {
        continue
    }

    print("Found picture: \(file)")
}

或者，使用**break**退出循环并跳过所有剩余的迭代。

函数 (Functions)

要创建新函数，请写上**func**然后加上函数名称，然后在括号内添加参数：

func printTimesTables(number: Int) {
    for i in 1...12 {
        print("\(i) x \(number) is \(i * number)")
    }
}

printTimesTables(number: 5)

我们需要在调用站点上写出**number: 5**，因为参数名称是函数调用的一部分。

要从函数中返回数据，请告诉Swift它是什么类型，然后使用**return**关键字将其发送回。例如，这返回一个掷骰子的结果：

func rollDice() -> Int {
    return Int.random(in: 1...6)
}

let result = rollDice()
print(result)

如果你的函数只包含一行代码，您可以删除**return**关键字：

func rollDice() -> Int {
    Int.random(in: 1...6)
}

从函数中返回多个值

元组存储了固定数量的特定类型的值，这是一种从函数返回多个值的便捷方法：

func getUser() -> (firstName: String, lastName: String) {
    (firstName: "Taylor", lastName: "Swift")
}

let user = getUser()
print("Name: \(user.firstName) \(user.lastName)")

如果你不需要元组中的所有值，你可以重组元组，将其拆分成单个值，然后用”_”告诉 Swift 忽略某些值：

let (firstName, _) = getUser()
print("Name: \(firstName)")

自定义参数标签 (Customizing parameter labels)

如果你在调用函数时不想传递参数的名称，请在它前面放置下划线：

func isUppercase(_ string: String) -> Bool {
    string == string.uppercased()
}

let string = "HELLO, WORLD"
let result = isUppercase(string)

另一种选择是在名字之前给它起另外一个名字：一个用于外部，一个用于内部：

func printTimesTables(for number: Int) {
    for i in 1...12 {
        print("\(i) x \(number) is \(i * number)")
    }
}

printTimesTables(for: 5)

在该代码中，**for外部使用，number**在内部使用。

为参数提供默认值

我们可以通过在类型后写一个等值来提供默认参数值，然后提供一个值，如下所示：

func greet(_ person: String, formal: Bool = false) {
	if formal {
        print("Welcome, \(person)!")
	  } else {
        print("Hi, \(person)!")
    }
}

现在我们可以用两种方式调用**greet()**）：

greet("Tim", formal: true)
greet("Taylor")

处理函数中的错误

要处理函数中的错误，你需要告诉Swift哪些错误可能发生，编写一个可以抛出错误的函数，然后调用它并处理任何问题。

首先，定义可能出现的错误：

enum PasswordError: Error {
    case short, obvious
}

接下来，编写一个可以抛出错误的函数。这是通过将**throws加入函数类型，然后使用throw**来触发特定错误来完成的：

func checkPassword(_ password: String) throws -> String {
    if password.count < 5 {
        throw PasswordError.short
    }

    if password == "12345" {
        throw PasswordError.obvious
    }

    if password.count < 10 {
        return "OK"
    } else {
        return "Good"
    }
}

现在通过启动**do块来调用抛出函数，使用try**调用函数，然后捕捉发生的错误：

let string = "12345"

do {
    let result = try checkPassword(string)
    print("Rating: \(result)")
} catch PasswordError.obvious {
    print("I have the same combination on my luggage!")
} catch {
    print("There was an error.")
}

当涉及到捕捉错误时，你必须始终有一个可以处理各种错误的**catch**块。

闭包 (Closures)

你可以将函数直接分配给像这样的常量或变量：

let sayHello = {
    print("Hi there!")
}

sayHello()

在该代码中，**sayHello**是一个闭包——一块代码，我们可以随时传递和调用。如果你希望闭包接受参数，它们必须写在大括号内：

let sayHello = { (name: String) -> String in
    "Hi \(name)!"
}

**in**用于标记参数的结束并返回类型——之后的所有内容都是闭包本身的主体。

闭包在Swift中被广泛使用。例如，有一个名为**filter()**的数组方法，它通过测试运行数组的所有元素，任何返回测试为true的元素都会在新数组中返回。

我们可以使用闭包提供该测试，因此我们可以过滤数组，仅包含以T开头的名称：

let team = ["Gloria", "Suzanne", "Tiffany", "Tasha"]

let onlyT = team.filter({ (name: String) -> Bool in
    return name.hasPrefix("T")
})

在闭包中，我们列出了传递给我们的参数**filter()），这是数组中的字符串。我们还说，我们的闭包返回一个布尔值，然后使用in**来标记闭包代码的开头——之后，其他一切都是正常的函数代码。

尾部闭包(Trailing closures)和速记语法(shorthand syntax)

Swift有一些诀窍，使结尾更容易阅读。以下是一些过滤数组的代码，只包含以“T”开头的名称：

let team = ["Gloria", "Suzanne", "Tiffany", "Tasha"]

let onlyT = team.filter({ (name: String) -> Bool in
    return name.hasPrefix("T")
})

print(onlyT)

你可以看到，闭包的主体只有一行代码，因此我们可以去掉return：

let onlyT = team.filter({ (name: String) -> Bool in
    name.hasPrefix("T")
})

**filter()**必须给出一个从其数组中接受一个项目的函数，如果它应该在返回的数组中，则返回true。

由于我们传递的函数必须有这样的行为，所以我们不需要在闭包中指定类型。所以，我们可以重写代码成这样：

let onlyT = team.filter({ name in
    name.hasPrefix("T")
})

我们可以进一步使用称为尾随闭包语法的特殊语法，如下所示：

let onlyT = team.filter { name in
    name.hasPrefix("T")
}

最后，Swift可以为我们提供简短的参数名称，因此我们甚至不再写入**name in，而是依赖为我们提供的特殊命名值：$0**：

let onlyT = team.filter {
    $0.hasPrefix("T")
}

结构体 (Structs)

结构允许我们创建自己的自定义数据类型，并完成它们自己的属性和方法：

struct Album {
    let title: String
    let artist: String
    var isReleased = true

    func printSummary() {
        print("\(title) by \(artist)")
    }
}

let red = Album(title: "Red", artist: "Taylor Swift")
print(red.title)
red.printSummary()

当我们创建结构实例时，我们使用初始化器来创建结构——Swift允许我们像函数一样对待结构，传递其每个属性的参数。它根据结构的属性无声地生成此成员初始化器。

如果你想让结构的方法更改其属性之一，请将其标记为突变：

mutating func removeFromSale() {
    isReleased = false
}

计算属性 (Computed properties)

计算属性在每次访问时都会计算其值。例如，我们可以编写一个**Employee**结构，跟踪该员工的剩余假期：

struct Employee {
    let name: String
    var vacationAllocated = 14
    var vacationTaken = 0

    var vacationRemaining: Int {
        vacationAllocated - vacationTaken
    }
}

为了能够写入给**vacationRemaining**，我们需要同时提供获取器(getter)和设置器(setter)：

var vacationRemaining: Int {
    get {
        vacationAllocated - vacationTaken
    }

    set {
        vacationAllocated = vacationTaken + newValue
    }
}

**newValue**由Swift提供，并存储用户分配给属性的任何值。

属性观察器 (Property observers)

属性观察器是属性更改时运行的代码片段：**didSet在属性刚刚更改时运行，willSet**在属性更改之前运行。

我们可以通过在分数更改时让**Game结构打印消息来演示didSet**：

struct Game {
    var score = 0 {
        didSet {
            print("Score is now \(score)")
        }
    }
}

var game = Game()
game.score += 10
game.score -= 3

自定义初始化器 (Custom initializers)

初始化器是一种特殊函数，用于准备要使用的新结构体实例，确保所有属性都有初始值。

Swift 会根据结构体的属性生成一个初始化器，但你也可以创建自己的初始化器：

struct Player {
    let name: String
    let number: Int

    init(name: String) {
        self.name = name
        number = Int.random(in: 1...99)
    }
}

重要：初始化程序前面没有 func，也不会明确返回值。

门禁控制（Access control)

Swift 为结构体内部的访问控制提供了多种选项，但最常见的有四种：

• 使用 private 表示 “不要让结构体之外的任何东西使用它”。
• 使用 private(set) 表示 “结构体之外的任何内容都可以读取此内容，但不要让它们更改”。
• 使用 fileprivate 表示 “不允许当前文件以外的任何内容使用此文件”。
• 使用 public 表示 “允许任何人在任何地方使用它”。

例如：

struct BankAccount {
    private(set) var funds = 0

    mutating func deposit(amount: Int) {
        funds += amount
    }

    mutating func withdraw(amount: Int) -> Bool {
        if funds > amount {
            funds -= amount
            return true
        } else {
            return false
        }
    }
}

因为我们使用了 private(set)，所以从结构体外部读取资金是可以的，但写入是不可能的。

静态属性和方法（Static properties and methods)

Swift 支持静态属性和方法，允许你将属性或方法直接添加到结构体本身，而不是结构体的某个实例：

struct AppData {
    static let version = "1.3 beta 2"
    static let settings = "settings.json"
}

使用这种方法，我们可以在任何需要检查或显示应用程序版本号的地方读取 AppData.version。

类（Classes）

类允许我们创建自定义数据类型，与结构体有五个不同之处。

第一个不同点是，我们可以通过继承其他类的功能来创建类：

class Employee {
    let hours: Int

    init(hours: Int) {
        self.hours = hours
    }

    func printSummary() {
        print("I work \(hours) hours a day.")
    }
}

class Developer: Employee {
    func work() {
        print("I'm coding for \(hours) hours.")
    }
}

let novall = Developer(hours: 8)
novall.work()
novall.printSummary()

如果子类要更改父类的方法，必须使用覆盖（override）：

override func printSummary() {
    print("I spend \(hours) hours a day searching Stack Overflow.")
}

第二个不同点是，类的初始化器更加复杂。这里有很多复杂之处，但有三个关键点：

1. Swift 不会为类生成成员初始化器。
2. 如果子类有自定义初始化器，它必须在设置完自己的属性后调用父类的初始化器。
3. 如果子类没有任何初始化器，它将自动继承父类的初始化器。

例如：

class Vehicle {
    let isElectric: Bool

    init(isElectric: Bool) {
        self.isElectric = isElectric
    }
}

class Car: Vehicle {
    let isConvertible: Bool

    init(isElectric: Bool, isConvertible: Bool) {
        self.isConvertible = isConvertible
        super.init(isElectric: isElectric)
    }
}

super 允许我们调用属于父类的方法，例如父类的初始化器。

第三个区别是，类实例的所有副本共享数据，这意味着对其中一个副本所做的更改会自动更改其他副本。

例如：

class Singer {
    var name = "Adele"
}

var singer1 = Singer()
var singer2 = singer1
singer2.name = "Justin"
print(singer1.name)  
print(singer2.name)

这将打印出两个相同的 “Justin”——尽管我们只更改了其中一个，但另一个也发生了变化。相比之下，结构体副本不会共享数据。

第四个区别是，类可以有一个去初始化器，当对象的最后一个引用被销毁时，去初始化器会被调用。

因此，我们可以创建一个类，在创建和销毁时打印一条信息：

class User {
    let id: Int

    init(id: Int) {
        self.id = id
        print("User \(id): I'm alive!")
    }

    deinit {
        print("User \(id): I'm dead!")
    }
}

for i in 1...3 {
    let user = User(id: i)
    print("User \(user.id): I'm in control!")
}

最后一个区别是，即使类本身不变，我们也可以通过类来更改变量属性：

class User {
    var name = "Paul"
}

let user = User()
user.name = "Taylor"
print(user.name)

因此，类在使用改变数据的方法时不需要使用**mutating**关键字。

协议（Protocols）

协议定义了我们期望数据类型支持的功能，Swift 确保我们的代码遵循这些规则。

例如，我们可以这样定义**Vehicle**协议：

protocol Vehicle {
    func estimateTime(for distance: Int) -> Int
    func travel(distance: Int)
}

这列出了该协议工作所需的方法，但不包含任何代码——我们只指定了方法名称、参数和返回类型。

一旦有了协议，就可以通过实现所需的功能来使数据类型符合协议。例如，我们可以创建一个符合**Vehicle**协议的 Car 结构：

struct Car: Vehicle {
    func estimateTime(for distance: Int) -> Int {
        distance / 50
    }

    func travel(distance: Int) {
        print("I'm driving \(distance)km.")
    }
}

Vehicle 中列出的所有方法必须完全存在于 Car 中，并且具有相同的名称、参数和返回类型。

现在，你可以编写一个接受任何符合 Vehicle 类型的函数，因为 Swift 知道它同时实现了 estimateTime() 和 travel()：

func commute(distance: Int, using vehicle: Vehicle) {
    if vehicle.estimateTime(for: distance) > 100 {
        print("Too slow!")
    } else {
        vehicle.travel(distance: distance)
    }
}

let car = Car()
commute(distance: 100, using: car)

协议也可以要求属性，因此我们可以要求车辆有多少个座位和目前有多少乘客的属性：

protocol Vehicle {
    var name: String { get }
    var currentPassengers: Int { get set }
    func estimateTime(for distance: Int) -> Int
    func travel(distance: Int)
}

这就增加了两个属性：一个是标有 **get**的属性，可能是常量或计算属性；另一个是标有 get set 的属性，可能是变量或带有 getter 和 setter 的计算属性。

现在，所有符合要求的类型都必须添加这两个属性的实现，比如**Car**的实现：

let name = "Car"
var currentPassengers = 1

提示：你可以根据需要遵守任意多个协议，只需用逗号分隔列出即可。

扩展（Extensions）

扩展可以让我们为任何类型添加功能。例如，Swift 的字符串有一个用于修剪空白和新行的方法，但它非常长，因此我们可以将它变成一个扩展：

extension String {
    func trimmed() -> String {
        self.trimmingCharacters(in: .whitespacesAndNewlines)
    }
}

var quote = "   The truth is rarely pure and never simple   "
let trimmed = quote.trimmed()

如果你想直接更改一个值，而不是返回一个新值，请像这样将方法标记为突变：

extension String {
    mutating func trim() {
        self = self.trimmed()
    }
}

quote.trim()

扩展还可以为类型添加计算属性，比如这个：

extension String {
    var lines: [String] {
        self.components(separatedBy: .newlines)
    }
}

components(separatedBy:) 方法使用我们选择的边界（在本例中是新行）将字符串分割成字符串数组。

现在，我们可以在所有字符串中使用该属性：

let lyrics = """
But I keep cruising
Can't stop, won't stop moving
"""

print(lyrics.lines.count)

协议扩展（Protocol extensions）

协议扩展扩展了整个协议，添加了计算属性和方法实现，因此任何符合该协议的类型都能获得它们。

例如，数组（Array）、字典（Dictionary）和集合（Set）都符合**Collection**协议，因此我们可以像这样为它们添加计算属性：

extension Collection {
    var isNotEmpty: Bool {
        isEmpty == false
    }
}

现在我们可以派上用场了：

let guests = ["Mario", "Luigi", "Peach"]

if guests.isNotEmpty {
    print("Guest count: \(guests.count)")
}

这种方法意味着我们可以在协议中列出所需的方法，然后在协议扩展中添加这些方法的默认实现。然后，所有符合要求的类型都可以使用这些默认实现，或根据需要提供自己的实现。

可选项（Optionals）

可选项表示没有数据，例如，可选项可以区分数值为 0 的整数和没有数值的整数。

要了解可选项的作用，请看这段代码：

let opposites = [
    "Mario": "Wario",
    "Luigi": "Waluigi"
]

let peachOpposite = opposites["Peach"]

它试图读取连接到键 “Peach”的值，而这个键并不存在，所以它不可能是一个普通字符串。Swift 的解决方案被称为可选项，即可能存在也可能不存在的数据。

一个可选字符串可能有一个字符串在里面等着我们，也可能什么都没有——一个叫做 nil 的特殊值，意思是 “无值”。任何类型的数据都可以是可选的，包括 Int、Double 和 Bool，以及枚举、结构体和类的实例。

Swift 不会让我们直接使用可选数据，因为它可能是空的。这意味着我们需要解包可选数据才能使用它——我们需要查看其内部是否存在值，如果存在，则取出并使用它。

Swift 提供了几种解包可选项的方法，但你最常见的方法是这样的：

if let marioOpposite = opposites["Mario"] {
    print("Mario's opposite is \(marioOpposite)")
}

这将从字典中读取可选值，如果可选值内有字符串，则将其解包——字符串将被放入 marioOpposite 常量中，不再是可选值。由于我们已经解开了可选值，因此条件成功，**print()**代码也就运行了。

用 guard 解包可选项

Swift 还有第二种解包可选项的方法，称为 guard let，它与 if let 非常相似，只是相反：如果可选项有值，if let 会运行括号内的代码；如果可选项没有值，guard let 会运行代码。

它看起来像这样：

func printSquare(of number: Int?) {
    guard let number = number else {
        print("Missing input")
        return
    }

    print("\(number) x \(number) is \(number * number)")
}

如果使用 guard 检查函数的输入是否有效，Swift 要求在检查失败时使用 return。但是，如果你正在解包的可选项内部有一个值，你可以在 guard 代码结束后使用它。

提示：你可以在任何条件下使用 guard，包括不解除可选项的条件。

空聚合（Nil coalescing）

Swift 还有第三种解包可选项的方法，称为空聚合操作符（nil coalescing operator），它可以解包可选项，并在可选项为空时提供默认值：

let tvShows = ["Archer", "Babylon 5", "Ted Lasso"]
let favorite = tvShows.randomElement() ?? "None"

在创建可选项的许多地方，空聚合操作符都很有用。例如，从字符串创建整数时会返回一个可选的 Int? 在这里，我们可以使用空聚合提供一个默认值：

let input = ""
let number = Int(input) ?? 0
print(number)

可选项链（Optional chaining）

可选项链读取可选项内的可选项，就像这样：

let names = ["Arya", "Bran", "Robb", "Sansa"]
let chosen = names.randomElement()?.uppercased()
print("Next in line: \(chosen ?? "No one")")

可选项链在第 2 行：一个问号，后面跟着更多代码。它允许我们说：“如果可选项里面有一个值，那么就把它拆开…… ”并添加更多代码。在我们的例子中，我们说的是 “如果我们从数组中得到了一个随机元素，就把它大写”。

可选项try?（Optional try?）

当调用一个可能会出错的函数时，我们可以使用 try? 将其结果转换为一个可选项，在成功时包含一个值，反之则为 nil。

如下所示：

enum UserError: Error {
    case badID, networkFailed
}

func getUser(id: Int) throws -> String {
    throw UserError.networkFailed
}

if let user = try? getUser(id: 23) {
    print("User: \(user)")
}

getUser() 函数总是会抛出 networkFailed，但我们并不关心抛出的是什么，我们只关心调用是否发回了用户。

总结

至此，我们一起学习了 Swift 语言的大部分基础知识，但实际上我们只是触及了这门语言的皮毛。幸运的是，我们所学到的知识已经足以让你使用 Swift 和 SwiftUI 构建一些出色的软件。

接下来，我们将开始学习SwiftUI来创建一些简单的App，如果你有兴趣请继续关注我的教程。

第2集 击杀炎尾龙

第1话 – 回到尼福尔海姆

第2话 – 调查魔晄炉

第3话 – 尼福尔海姆惨剧

第4话 – 逃避追兵

第5话 – 格林牧场

第6话 – 万能帮手

第7话 – 打牌高手

第8话 – 贝格公司

第9话 – 召唤兽泰坦

第10话 – 越过湿地

第11话 – 秘银矿迷宫

第12话 – 登山陆行鸟

第13话 – 尤菲登场

第14话 – 探索下珠诺

第15话 – 探索下珠诺 2

第16话 – 兀鹰堡垒

第17话 – 万能帮手珠诺分店

第18话 – 神罗总裁奖

第19话 – 偷渡

第20话 – 女王之血大奖赛

第21话 – 海上惊魂夜

第22话 – 太阳乐园

第23话 – 阳光海滩

第24话 – 假期结束

第25话 – 万能帮手太阳海岸篇

第26话 – 登上科雷陆山

第27话 – 大显身手的尤菲

第28话 – 衰落的村庄

第29话 – 鬼屋酒店

第30话 – 金蝶游乐园

第1话 – 逆转的访客

第1节 前篇

第2节 后篇 完结

第2话 – 逆转的客机

第1节 前篇

第2节 中篇

第3节 后篇1

第4节 后篇2 结局

第3话 – 绑票的逆转

第1节 前篇 开场

第2节 中篇 找出目击者

第3节 中篇 与丈一郎等人会合

第4节 后篇 最终对决 前半段

第1节是案件的开始，成步堂和真宵、春美一起前往叶樱院参加修行，于是在第一晚遇见了凶杀案。

第2节 – 调查后篇

御剑被矢张从国外叫回，代替成步堂进行调查并答应为被告人辩护。

第3节 – 第一次法庭前篇

御剑代替成步堂站上法庭为被告人辩护，没想到对方检察官竟然是……

第4节 – 第一次法庭后篇

御剑将矢张拖上法庭证人席，却没想到矢张展示出一份惊人的证据震惊全场所有人。

第5节 – 第二次调查前篇

成步堂带病去现场考察，胧桥总算修好可以到达对岸了，可是……

第6节 – 第二次调查后篇

成步堂通过调查终于掌握了案件的真正背景，接下来就等法庭上见了！

第7节 – 第二次法庭前篇

第8节 – 第二次法庭后篇

第9节 – 第二次法庭后篇2 大结局

花子与安妮

日剧

156集

2023年10月26日开播

2024年1月11日END

评论

★★★★☆

晨间剧的经典剧情模式，人的一生所能经历的所有故事，不少细节都很真实，值得一看。

今晚是寿喜烧哦

日剧

12集

2024年1月12日开播

2024年1月20日END

评论

★★★★☆

没想到意外的好看，生活味的日剧总是比较不错。

别穿越时空了，恋人们

日剧

11集

2024年1月21日START

2024年1月30日END

评论

★★★☆☆

这编剧……真幼稚

复仇的未亡人

日剧

8集

2024年1月31日START

2024年2月7日END

评论

★★☆☆☆

这是什么乱七八糟的结尾…

月读君的禁忌夜宵

日剧

9集

2024年2月8日START

2024年2月26日END

评论

★★★☆☆

要想征服一个女人也要征服她的胃，是想表达这个意思吗？

A2Z

日剧

10集

2024年2月27日START

2024年4月10日END

评价

★★★☆☆

这故事的构思有点莫名其妙。

单身花日

日剧

9集

2024年4月11日START

2024年4月20日END

评价

★★☆☆☆

如此狗血的剧情以及演得像个傻子的重冈大毅。

三体 第1季

美剧

8集

2024年4月21日START

2024年4月23日END

评价

★★★★☆

抛开与原作的对比，本剧其实拍得很不错了。期待第二季。

相棒 Season 1

日剧

12集

2024年4月23日START

2024年5月1日END

评价

★★★★☆

案件比较新颖，且都具有现实意义。表现手法也比较有趣，更何况是20多年前的电视剧。

夫妻圆满秘诀

日剧

11集

2024年5月16日START

2024年5月27日END

评价

★☆☆☆☆

拍这种片子有什么意义吗？

高堡奇人 第1季

美剧

10集

2024年5月28日START

2024年6月29日END

评价

★★★☆☆

节奏过于缓慢，进度不佳。

高堡奇人 第2季

美剧

10集

2024年6月30日START

2024年7月28日END

评价

★★★★☆

第二季的节奏比第一季要好，但还是比较拖，激励人一直看下去的点依然不足。

高堡奇人 第3季

美剧

10集

2024年7月30日START

2024年8月31日END

评价

★★★☆☆

节奏慢得有点受不了

高堡奇人 第4季

美剧

10集

2024年9月1日START

2024年9月4日END

评价

★★☆☆☆

不行了，实在受不了的节奏慢，只能半途而废。

各自孤独的美食家

日剧

12集

2024年11月1日～

评价

★★★☆☆

这一部孤独的美食家是最差的一部，拍的太刻意了，演得也太刻意了。

午间档

少年谢尔顿 第1季

美剧

22集

2023年12月16日START

2023年12月25日END

评论

★★★★★

9岁的谢尔顿比30岁的谢尔顿可爱1万倍！

少年谢尔顿 第2季

美剧

22集

2023年12月26日START

2024年1月2日END

评论

★★★★☆

最后一集很是感触。

少年谢尔顿 第3季

美剧

21集

2024年1月3日START

2024年1月11日END

评论

★★★★☆

谢尔顿这坏脾气到底是怎么养成的？

少年谢尔顿 第4季

美剧

18集

2024年1月12日START

2024年1月20日END

评论

★★★★☆

第四季略显不足，特别是最后一集感觉没有起伏性。

少年谢尔顿 第5季

22集

2024年1月21日START

2024年1月29日END

评论

★★★★☆

第五季谢尔顿的戏份有所减少，家庭成员的故事占比上升，这很好。

少年谢尔顿 第6季

美剧

22集

2024年1月30日START

2024年2月10日END

评论

★★★★★

谢尔顿其实是最蠢的那个人

繁花

30集

中国大陆剧

2024年2月10日START

2024年2月27日END

评论

★★★★☆

作为大陆剧，已经是近几年拍得最好的一部了。每个上海人都可以看一看。

相棒 Pre-Season

日剧

3集

2024年3月24日START

2024年3月28日END

评价

★★★★☆

开始追相棒系列，希望它一直能那么有趣。

少年谢尔顿 第7季 FINAL Season

美剧

14集

2024年5月28日START

2024年6月16日END

评价

★★★★★

最后一季，最催人泪下的一季。

与雪女同行吃蟹

日剧

12集

2024年6月17日START

2024年6月19日END

评价

★★★☆☆

不知道导演是不是想拍成公路片，但如果是，无疑比较失败，虽然故事本身是吸引人的。另外，重冈大毅怎么现在演什么角色都像个傻子？

下北泽 Die Hard

日剧

11集

2024年6月20日START

2024年7月2日END

评价

★★★☆☆

本剧属于好玩，但还谈不上有趣。

量产型璃子-另一位模型女子的人生组装记-

日剧

10集

2024年7月3日START

2024年7月15日END

评价

★★★☆☆

比第一部在刻画人物个性和剧情走向上差了许多，好像只是为了做模型而去做模型。

湿身侦探水野羽衣

日剧

12集

2024年7月16日START

2024年8月26日END

评价

★★★☆☆

无聊打发时间的搞笑剧

学园爆笑王

日剧

8集

2024年8月27日START

2024年9月4日END

评价

★★★☆☆

中国人看日本的漫才是很难感同身受的笑出来的，但本剧还是有不少笑点，最大的遗憾是数金这对组合的剧情光辉掩盖了主角的光芒，喧宾夺主了一大把！

硅谷 第1季

美剧

8集

2024年9月5日START

2024年10月6日END

评价

★★★★★

非常有趣！

硅谷 第2季

美剧

10集

2024年10月7日START

2024年10月9日END

评价

★★★★★

第二季依然乐趣非凡！

硅谷 第3季

美剧

10集

2024年10月9日START

2024年10月17日END

评价

★★★★☆

第3季故事开始有些松散，笑料依然很多，但情节已不如前两季紧张。

硅谷 第4季

美剧

10集

2024年10月17日START

2024年10月20日END

评价

★★★★☆

这季唯一的缺点就是Richard的行为跳跃得过快。

硅谷 第5季

美剧

8集

2024年10月20日START

2024年10月23日END

评价

★★★★★

绝处逢生是Richard的运气太好了。

硅谷 第6季 最终季

7集

美剧

2024年10月24日START

2024年10月25日END

评价

★★★★★

到最后竟是一场空空！

警视厅零系：生活安全科万能咨询室 第四季

日剧

8集

2024年10月25日START

2024年11月7日END

评价

★★☆☆☆

挺无聊的

晚间档

神盾局特工 第2季

美剧

22集

2023年11月7日开播

2024年7月24日END

评价

★★★★☆

这一季拖拖拉拉看了很久，终于看完了。核心人物的忠心让人很安心。

神盾局特工 第3季

美剧

22集

2024年7月24日开播

2024年11月20日END

评价

★★★★☆

实话实说，这一季好混乱。

睡前档

孤独のグルメ 2023大晦日スペシャル

日剧

SP

2024年1月1日

评论

★★★★☆

五郎老亦，还能饭否？

シェアハウスの恋人

日剧

9集

2024年1月4日START

2024年1月13日END

评论

★★★☆☆

虽然有不少笑点，但故事写得真有些乱七八糟。

她和她的她

台湾

9集

2024年1月13日START

2024年1月21日END

评论

★★★★☆

最后一集有点不够悬疑，毕竟前面赚足了疑惑，最后解惑却显得“不过如此”。

说100万次就好了

日剧

10集

2024年1月22日START

2024年1月26日END

评论

★★★☆☆

最后一集真的是大败笔

日本沉没—希望之人—

日剧

9集

2024年1月27日START

2024年1月31日END

评论

★★★★☆

非主角的女友

日剧

12集

2024年2月1日START

2024年2月4日END

评论

★★★★☆

意外的把出轨演绎得很有趣

0.5的男人

日剧

5集

2024年2月26日START

2024年2月27日END

评论

★★★★☆

很有趣的一家人

兽医杜立德

日剧

9集

2024年3月23日START

2024年4月15日END

评论

★★★☆☆

马马虎虎的一部有关动物和人的医疗剧。

17.3关于性

日剧

9集

2024年4月11日START

2024年4月14日END

评论

★★★☆☆

朝日君属于不真实的理智。像他这个年纪的高中男生几乎没有他这样的冷静。

相棒 Season 2

日剧

21集

2024年5月2日START

2024年6月1日END

评论

★★★★☆

最后一集的浅仓死得有些太简单了点，枉费了他平成剪刀手的称号。

前男友的遗书

日剧

11集

2024年6月2日START

2024年6月30日END

评论

★★★☆☆

出彩的是第十集，而最平淡的是最后一集，编剧是写累了吧，从没见过这么无聊的大结局。

相棒 第3季

日剧

19集

2024年7月1日START

2024年8月28日END

评价

★★★★☆

No Side Game

日剧

10集

2024年8月29日START

2024年10月31日END

评价

★★★★☆

虽然职场斗争部分看起来有点儿戏，但球场部分却热血沸腾！

法医学者柚木贵志的案件

日剧

9集

2024年11月1日START

2024年11月8日END

评价

★★★☆☆

最后一集，其实完全没必要牺牲柚木医生。

My Family

日剧

10集

2024年11月9日～2024年11月15日

评价

★★★★☆

本剧最悲剧的人物就是东堂，编剧完全牺牲了他，导致我给本剧的评分只能是四颗星。

白衣战士

日剧

10集

2024年11月16日～2024年11月28日

评价

★★★☆☆ 

还算是有趣吧

被捡到的男人

日剧

10集

2024年11月29日～2025年1月4日

评价

★★★★☆ 

亲情、友情的故事总是很感人