Swift提供了多种控制流语句。其中包括while循环，用于多次执行任务；if、guard和switch语句，用于根据特定条件执行不同的代码分支；break和continue等语句用于将执行流转移到代码中的另一个点。

Swift还提供了一个for-in循环，可以方便地遍历数组、字典、范围、字符串和其他序列。

Swift的switch语句比许多类似C语言的switch语句强大得多。case可以匹配许多不同的模式，包括间隔匹配、元组和特定类型的强制转换。switch case中的匹配值可以绑定到临时常量或变量，以便在case的主体中使用，复杂的匹配条件可以用where子句表示。

For-In循环

我们可以使用for-in循环来迭代序列，例如数组中的元素、数字范围或字符串中的字符。

此示例使用for-in循环迭代数组中的元素：

let names = ["Anna", "Alex", "Brian", "Jack"]
for name in names {
    print("Hello, \(name)!")
}
// Hello, Anna!
// Hello, Alex!
// Hello, Brian!
// Hello, Jack!

我们还可以迭代字典以访问其键值对。迭代字典时，字典中的每个项都作为(key, value)元组返回，我们可以将(key, value)元组的成员分解为显式命名的常量，以便在for-in循环体中使用。在下面的代码示例中，字典的键被分解为一个名为animalName的常量，字典的值被分解为一个名为legCount的常量。

let numberOfLegs = ["spider": 8, "ant": 6, "cat": 4]
for (animalName, legCount) in numberOfLegs {
    print("\(animalName)s have \(legCount) legs")
}
// cats have 4 legs
// ants have 6 legs
// spiders have 8 legs

字典的内容本来就是无序的，对它们进行迭代并不能保证检索它们的顺序。特别是，将项插入字典的顺序并不代表它们的迭代顺序。有关数组和字典的详细信息，请参见集合类型。

我们还可以对数字范围使用for-in循环。此示例打印五倍表中的前几个条目：

for index in 1...5 {
    print("\(index) times 5 is \(index * 5)")
}
// 1 times 5 is 5
// 2 times 5 is 10
// 3 times 5 is 15
// 4 times 5 is 20
// 5 times 5 is 25

迭代的序列是一个从1到5的数字范围（包括1到5），如使用闭合范围运算符（…）所示。index的值被设置为范围（1）中的第一个数字，循环中的语句被执行。在本例中，循环只包含一条语句，该语句从索引的当前值的五倍表中打印一个条目。执行语句后，index的值将更新为包含范围（2）中的第二个值，并且print(_:separator:terminator:)函数被再次调用。此过程将一直继续，直到到达范围的终点。

在上面的示例中，index是一个常量，其值在循环的每次迭代开始时自动设置。因此，index 在使用前不必声明。它只通过包含在循环声明中而隐式声明，不需要let关键字声明。

如果不需要序列中的每个值，可以使用下划线代替变量名来忽略这些值。

let base = 3
let power = 10
var answer = 1
for _ in 1...power {
    answer *= base
}
print("\(base) to the power of \(power) is \(answer)")
// Prints "3 to the power of 10 is 59049"

上面的例子是计算一个数的另一个数次幂的值（在本例中，3的10次幂的值）。它使用从1开始到10结束的闭合范围，将起始值1（即3的0次幂）乘以3，一共10次。对于这种计算，每次通过循环的单个计数器值都是不必要的，因为代码只是保证执行循环多少次。替换循环变量时使用的下划线字符(_) 就会忽略各个值，并且在循环的每次迭代期间不提供对当前值的访问。

在某些情况下，可能不希望使用包含两个端点的闭合范围。比如在时钟表面画每分钟的刻度线。你要画60个记号，从0分钟开始。使用半开范围运算符（…<）包括下限，但不包括上限。有关范围的详细信息，请参见范围运算符。

let minutes = 60
for tickMark in 0..<minutes {
    // render the tick mark each minute (60 times)
}

一些用户可能希望UI中的记号更少。他们可能更喜欢每5分钟一次。使用stride(from:to:by:)函数跳过不需要的标记。

let minuteInterval = 5
for tickMark in stride(from: 0, to: minutes, by: minuteInterval) {
    // render the tick mark every 5 minutes (0, 5, 10, 15 ... 45, 50, 55)
}

通过stride(from:through:by:)函数，也可以使用闭合范围：

let hours = 12
let hourInterval = 3
for tickMark in stride(from: 3, through: hours, by: hourInterval) {
    // render the tick mark every 3 hours (3, 6, 9, 12)
}

While循环

while循环执行一组语句，直到条件变为false。在第一次迭代开始之前，迭代次数未知时，最好使用这些类型的循环。Swift提供两种while循环：

• While 在每次循环的开始处评估其条件。
• repeat-while在每次循环的结束时评估其条件。

While

while循环从计算单个条件开始。如果条件为真，则重复一组语句，直到条件变为假。
下面是while循环的一般形式：

截屏2021-02-23 下午2.30.41.png

这个例子展示了一个简单的蛇和梯子的游戏（也称为斜槽和梯子）：

截屏2021-02-23 下午2.31.18.png

游戏规则如下：

• 棋盘有25个方格，目标是在25个方格上或25个方格外着陆。
• 玩家的起始方格是“零方格”，就在棋盘左下角。
• 每回合，你掷一个六边形骰子，并按照上面虚线箭头所示的水平路径移动相应数量的方块。
• 如果你的回合在梯子底部结束，你就向上爬。
• 如果你的回合在蛇头结束，你就顺着那条蛇往下走。

游戏板由Int数组表示。它的大小基于一个名为finalSquare的常量，该常量用于初始化数组，也用于在本例后面的部分中检查胜利的条件。因为玩家从棋盘的“零”位置上开始，棋盘是用26个Int类型的零值初始化的，而不是25个。

let finalSquare = 25
var board = [Int](repeating: 0, count: finalSquare + 1)

然后，将一些正方形设置为具有蛇和梯子的特定值。带梯子底座的正方形有一个正数可以使你在棋盘上向上移动，而带蛇头的正方形有一个负数可以使你在棋盘上向下移动。

board[03] = +08; board[06] = +11; board[09] = +09; board[10] = +02
board[14] = -10; board[19] = -11; board[22] = -02; board[24] = -08

方块3包含了一个梯子的底部，可以把你推到方块11。为了表示这一点，board[03]等于+08，这相当于8的整数值（3和11之间的差）。为了对齐值和语句，一元加号运算符（+i）显式与一元减号运算符（-i）一起使用，小于10的数字用零填充。（这两种文体技巧都不是绝对必要的，但它们会使代码更整洁。）

var square = 0
var diceRoll = 0
while square < finalSquare {
    // roll the dice
    diceRoll += 1
    if diceRoll == 7 { diceRoll = 1 }
    // move by the rolled amount
    square += diceRoll
    if square < board.count {
        // if we're still on the board, move up or down for a snake or a ladder
        square += board[square]
    }
}
print("Game over!")

上面的例子使用了一个非常简单的方法来掷骰子。它不是生成随机数，而是让diceRoll值从0开始。每次通过while循环，diceRoll都会增加1，然后检查它是否变得过大。每当此返回值等于7时，骰子卷就变得太大，并重置为1。结果是骰子滚动值的序列总是1、2、3、4、5、6、1、2等等。

掷完骰子后，玩家向前移动骰子。掷骰子可能把玩家移到25号方格以外，这样游戏就结束了。为了处理这种情况，代码检查square是否小于board数组的count属性。如果square有效，board[square]中存储的值将添加到当前的square值中，以使玩家在任何梯子或蛇上下移动。

注意
如果不执行此检查，board[square]可能会尝试访问board数组边界之外的值，这将触发运行时错误。

然后，当前while循环执行结束，并检查循环的条件以查看是否应该再次执行循环。如果玩家已经移动到25号或25号以上，循环的条件计算为false，游戏结束。

在这种情况下，while循环是合适的，因为while循环开始时游戏的长度并不清楚。而是循环一直执行，直到满足特定条件为止。

Repeat-While

while循环的另一个变体，称为repeat-while循环，在考虑循环的条件之前，首先执行循环块的单次过程。然后继续重复循环，直到条件为false。
注意
Swift中的repeat-while循环类似于其他语言中的do-while循环。
重复while循环的一般形式如下：

截屏2021-02-23 下午2.34.09.png

下面是Snakes和Ladders的例子，写为repeat-while循环而不是while循环。finalSquare、board、square和diceRoll的值的初始化方式与while循环完全相同。

let finalSquare = 25
var board = [Int](repeating: 0, count: finalSquare + 1)
board[03] = +08; board[06] = +11; board[09] = +09; board[10] = +02
board[14] = -10; board[19] = -11; board[22] = -02; board[24] = -08
var square = 0
var diceRoll = 0

在这个版本的游戏中，循环中的第一个动作是检查梯子或蛇。棋盘上没有梯子可以把玩家直接带到25号方格，因此不可能通过梯子向上移动来赢得比赛。因此，作为循环中的第一个动作，检查蛇或梯子是安全的。

游戏开始时，玩家处于游戏板“零”位置。board[0]始终等于0，并且没有任何效果。

repeat {
    // move up or down for a snake or ladder
    square += board[square]
    // roll the dice
    diceRoll += 1
    if diceRoll == 7 { diceRoll = 1 }
    // move by the rolled amount
    square += diceRoll
} while square < finalSquare
print("Game over!")

代码检查蛇和梯子后，掷骰子，玩家掷骰子，方块向前移动。然后，当前循环执行结束。

循环的条件（while square<finalSquare）与之前相同，但这次直到循环的第一次运行结束时才对其进行计算。repeat-while 循环的结构比上一个例子中的while循环更适合这个游戏。在上面的repeat-while循环中，square += board[square]总是在循环的while条件确认square仍然在游戏板上之后立即执行。这个操作避免了在上例中描述的游戏的while循环的版本中看到的数组边界检查的需要。

条件语句

根据特定条件执行不同的代码段通常很有用。我们可能希望在发生错误时运行一段额外的代码，或者在值过高或过低时显示一条消息。要做到这一点，需要将部分代码设置为有条件的执行。

Swift提供了两种向代码中添加条件分支的方法：if语句和switch语句。通常，我们使用if语句来评估产生结果可能很少的简单条件。switch语句更适合于具有多种可能排列的更复杂的条件，在模式匹配可以帮助选择要执行的适当的代码分支的情况下非常有用。

if

在最简单的形式中，if语句有一个if条件。它只在条件为真时执行一组语句。

var temperatureInFahrenheit = 30
if temperatureInFahrenheit <= 32 {
    print("It's very cold. Consider wearing a scarf.")
}
// Prints "It's very cold. Consider wearing a scarf."

上面的例子检查温度是否低于或等于32华氏度（水的冰点）。如果是，则打印一条消息。否则，不会打印任何消息，并且在if语句的右大括号之后继续执行代码。

if语句可以为if条件为false的情况提供另一组语句，称为else子句。这些语句由else关键字表示。

temperatureInFahrenheit = 40
if temperatureInFahrenheit <= 32 {
    print("It's very cold. Consider wearing a scarf.")
} else {
    print("It's not that cold. Wear a t-shirt.")
}
// Prints "It's not that cold. Wear a t-shirt."

总是执行这两个分支中的一个。因为温度已经上升到华氏40度，天气不再冷到建议戴围巾，所以else分支被触发。

可以将多个if语句链接在一起以考虑附加子句。

temperatureInFahrenheit = 90
if temperatureInFahrenheit <= 32 {
    print("It's very cold. Consider wearing a scarf.")
} else if temperatureInFahrenheit >= 86 {
    print("It's really warm. Don't forget to wear sunscreen.")
} else {
    print("It's not that cold. Wear a t-shirt.")
}
// Prints "It's really warm. Don't forget to wear sunscreen."

在这里，增加了一个额外的if语句来响应特别温暖的温度。最后一个else子句仍然存在，它将打印对任何既不太热也不太冷的温度的响应。

但是，最后的else子句是可选的，如果不需要完整的条件集，则可以将其排除在外。

temperatureInFahrenheit = 72
if temperatureInFahrenheit <= 32 {
    print("It's very cold. Consider wearing a scarf.")
} else if temperatureInFahrenheit >= 86 {
    print("It's really warm. Don't forget to wear sunscreen.")
}

由于温度既不太冷也不太热，无法触发if或else if条件，因此不会打印任何消息。

switch

switch语句考虑一个值，并将其与几种可能的匹配模式进行比较。然后，它根据成功匹配的第一个模式执行适当的代码块。switch语句提供了if语句的另一种选择，用于响应多个潜在状态。

在最简单的形式中，switch语句将一个值与一个或多个相同类型的值进行比较。

截屏2021-02-23 下午2.38.19.png

每个switch语句都由多个可能的case组成，每个case都以case关键字开头。除了与特定的值进行比较之外，Swift还为每种情况提供了几种方法来指定更复杂的匹配模式。本章后面将介绍这些选项。

就像if语句的主体一样，每种case都是代码执行的一个独立分支。switch语句决定应该选择哪个分支。这个过程被称为转换正在考虑的值。

每个switch语句都必须详尽无遗。也就是说，所考虑类型的每一个可能值都必须与其中一个switch情况匹配。如果不能为每个可能的值提供一个case，那么可以定义一个默认case来覆盖任何没有显式定位的值。默认情况由default关键字表示，并且必须始终出现在最后。

此示例使用switch语句来考虑一个名为someCharacter的小写字符：

let someCharacter: Character = "z"
switch someCharacter {
case "a":
    print("The first letter of the alphabet")
case "z":
    print("The last letter of the alphabet")
default:
    print("Some other character")
}
// Prints "The last letter of the alphabet"

switch语句的第一个case与英文字母表的第一个字母a匹配，第二个case与最后一个字母z匹配。由于switch必须为每个可能的字符（而不仅仅是每个字母）都提供case，因此，此switch语句使用默认case来匹配除a和z以外的所有字符。此规定确保switch语句是全面的。

没有隐含的错误

与C和Objective-C中的switch语句不同的是，Swift中的switch语句在默认情况下不会从每个case的底部进入下一个case。相反，当第一个匹配的switch case完成时，整个switch语句就完成了它的执行，而不需要显式的break语句。这使得switch语句比C中的switch语句更安全、更易于使用，并且避免了错误地执行多个switch语句。

注意
尽管Swift中不需要break，但是我们可以使用break语句来匹配和忽略特定的案例，或者在案例完成执行之前中断匹配的案例。有关详细信息，请参见Switch语句中的Break。

每个case的主体必须至少包含一个可执行语句。编写以下代码无效，因为第一个case的主体为空：

let anotherCharacter: Character = "a"
switch anotherCharacter {
case "a": // Invalid, the case has an empty body
case "A":
    print("The letter A")
default:
    print("Not the letter A")
}
// This will report a compile-time error.

与C中的switch语句不同，这个switch语句不会同时匹配“a”和“A”。相反，它会报告一个编译时错误，即case “a”：不包含任何可执行语句。这种方法避免了从一个案例到另一个案例的意外失误，并使代码更加安全，其意图更加清晰。

要使Switch的case同时匹配“a”和“a”，请将这两个值组合成一个复合大小写，并用逗号分隔这些值。

let anotherCharacter: Character = "a"
switch anotherCharacter {
case "a", "A":
    print("The letter A")
default:
    print("Not the letter A")
}
// Prints "The letter A"

为了可读性，复合大小写也可以写在多行上。有关复合案例的详细信息，请参见复合案例。

注意
要在特定的switch case的末尾显式地置空，请使用fallthrough关键字，如 fallthrough 中所述。

区间匹配

可以检查switch-case中的值是否包含在某个间隔中。此示例使用数字间隔为任意大小的数字提供自然语言计数：

let approximateCount = 62
let countedThings = "moons orbiting Saturn"
let naturalCount: String
switch approximateCount {
case 0:
    naturalCount = "no"
case 1..<5:
    naturalCount = "a few"
case 5..<12:
    naturalCount = "several"
case 12..<100:
    naturalCount = "dozens of"
case 100..<1000:
    naturalCount = "hundreds of"
default:
    naturalCount = "many"
}
print("There are \(naturalCount) \(countedThings).")
// Prints "There are dozens of moons orbiting Saturn."

在上面的示例中，approximateCount是在switch语句中评估的。每种case都将该值与一个数字或间隔进行比较。因为approximateCount的值介于12和100之间，所以naturalCount被赋值为“dozens of”，执行过程从switch语句中转出。

多元组

可以同一switch语句中使用元组测试多个值。元组的每个元素都可以根据不同的值或值间隔进行测试。或者，也可以使用下划线 (_)，也称为通配符模式，来匹配任何可能的值。

下面的示例获取一个（x，y）点，表示为（Int，Int）类型的简单元组，并在下面的示例图中对其进行分类。

let somePoint = (1, 1)
switch somePoint {
case (0, 0):
    print("\(somePoint) is at the origin")
case (_, 0):
    print("\(somePoint) is on the x-axis")
case (0, _):
    print("\(somePoint) is on the y-axis")
case (-2...2, -2...2):
    print("\(somePoint) is inside the box")
default:
    print("\(somePoint) is outside of the box")
}
// Prints "(1, 1) is inside the box"

截屏2021-02-23 下午2.44.20.png

switch语句确定该点是位于原点（0，0）、红色x轴上、橙色y轴上、以原点为中心的蓝色4x4框内还是框外。

与C不同，Swift允许多个switch-case考虑相同的值。事实上，点（0，0）可以匹配本例中的所有四种情况。但是，如果可能有多个匹配，则始终使用第一个匹配的case。点（0，0）将首先匹配case（0，0），因此将忽略所有其他匹配的case。

值绑定

switch case可以命名与临时常量或变量匹配的一个或多个值，以便在case的主体中使用。这种行为称为值绑定，因为值被绑定到case的主体中的临时常量或变量。

下面的示例以（x，y）点为例，表示为（Int，Int）类型的元组，并在下面的图中对其进行分类：

let anotherPoint = (2, 0)
switch anotherPoint {
case (let x, 0):
    print("on the x-axis with an x value of \(x)")
case (0, let y):
    print("on the y-axis with a y value of \(y)")
case let (x, y):
    print("somewhere else at (\(x), \(y))")
}
// Prints "on the x-axis with an x value of 2"

截屏2021-02-23 下午2.45.45.png

switch语句确定该点是在红色x轴上、橙色y轴上还是在其他位置（两个轴都不在）。

三个switch case声明占位符常量x和y，它们临时从 anotherPoint 获取一个或两个元组值。第一种情况 case (let x, 0)，匹配y值为0的任何点，并将该点的x值指定给临时常量x。类似地，第二种情况case (0, let y)匹配x值为0的任何点，并将该点的y值指定给临时常量y。

声明临时常量后，可以在case的代码块中使用它们。在这里，它们用于打印点的类型。

此switch语句没有默认case。最后一个case，case let (x, y)，声明了一个由两个占位符常量组成的元组，可以匹配任何值。因为另一个点总是由两个值组成的元组，所以这个大小写匹配所有可能的剩余值，并且不需要使用默认case 来使switch语句全面。

where

switch case可以使用where子句检查附加条件。
下面的示例对下图中的（x，y）点进行了分类：

let yetAnotherPoint = (1, -1)
switch yetAnotherPoint {
case let (x, y) where x == y:
    print("(\(x), \(y)) is on the line x == y")
case let (x, y) where x == -y:
    print("(\(x), \(y)) is on the line x == -y")
case let (x, y):
    print("(\(x), \(y)) is just some arbitrary point")
}
// Prints "(1, -1) is on the line x == -y"

截屏2021-02-23 下午2.46.55.png

switch语句确定该点是在x == y的绿色对角线上，还是在x == -y的紫色对角线上，或者两者都不在。

这三个switch实例声明占位符常量x和y，它们临时接受来自 yetAnotherPoint 的两个元组值。这些常量用作where子句的一部分，用于创建动态筛选器。只有当where子句的条件对该值的计算结果为true时，switch case才与point的当前值匹配。

与上一个示例一样，最后一个case匹配所有可能的剩余值，因此不需要使用默认case来使switch语句全面。

复合case

共享同一主体的多个switch case可以通过在case之后编写多个模式来组合，每个模式之间使用逗号隔开。如果任何一个模式匹配，那么case就被认为是匹配的。如果列表很长，则可以将模式写在多行上。例如：

let someCharacter: Character = "e"
switch someCharacter {
case "a", "e", "i", "o", "u":
    print("\(someCharacter) is a vowel")
case "b", "c", "d", "f", "g", "h", "j", "k", "l", "m",
     "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z":
    print("\(someCharacter) is a consonant")
default:
    print("\(someCharacter) isn't a vowel or a consonant")
}
// Prints "e is a vowel"

switch语句的第一个case匹配英语中五个小写元音字符。同样，它的第二个case匹配所有小写的英语辅音。最后，默认case匹配任何其他字符。

复合case还可以包括值绑定。复合case的所有模式都必须包含相同的值绑定集，并且每个绑定必须从复合case的所有模式中获取相同类型的值。这可以确保，无论复合case的哪个模式匹配成功，case主体中的代码始终可以访问绑定的值，并且该绑定值始终具有相同的类型。

let stillAnotherPoint = (9, 0)
switch stillAnotherPoint {
case (let distance, 0), (0, let distance):
    print("On an axis, \(distance) from the origin")
default:
    print("Not on an axis")
}
// Prints "On an axis, 9 from the origin"

上面的case有两种模式：(let distance, 0)匹配x轴上的点，(0, let distance)匹配y轴上的点。这两种模式都包含一个distance绑定，distance在这两种模式中都是整数，这意味着case主体中的代码始终可以访问distance值，并且都是整数类型。

控制转移语句

控制转移语句通过将控制权从一段代码转移到另一段代码来更改代码的执行顺序。Swift有五种控制权转移声明：

• continue
• break
• fallthrough
• return
• throw

下面将描述continue、break和fallthrough语句。return语句在函数中描述，throw语句在使用抛出函数传递错误中描述。

continue

continue语句告诉循环停止它正在做的事情，并在循环的下一次迭代开始处重新开始。它说“我已经完成了当前的循环迭代”，而没有完全离开循环。

以下示例删除小写字符串中的所有元音和空格，以创建一个神秘的拼图短语：

let puzzleInput = "great minds think alike"
var puzzleOutput = ""
let charactersToRemove: [Character] = ["a", "e", "i", "o", "u", " "]
for character in puzzleInput {
    if charactersToRemove.contains(character) {
        continue
    }
    puzzleOutput.append(character)
}
print(puzzleOutput)
// Prints "grtmndsthnklk"

上面的代码在匹配元音或空格时调用continue关键字，导致循环的当前迭代立即结束，并直接跳到下一个迭代的开始。

中断

break语句立即结束整个控制流语句的执行。当我们希望在执行其他case之前终止执行switch或loop语句时，可以在switch或loop语句中使用break语句。

中断循环语句

当在循环语句中使用时，break会立即结束循环的执行，并将控制权传递给在循环的右大括号（}）之后的代码。不会执行循环当前迭代中的其他代码，也不会开始循环的其他迭代。

中断Switch语句

在switch语句中使用break时，会导致switch语句立即结束执行，并将控制权转移到switch语句的右括号（}）后面的代码。

此行为可用于匹配和忽略switch语句中的一个或多个case。因为Swift的switch语句是详尽无遗的，并且不允许出现空的情况，所以有时有必要故意匹配和忽略一个情况，以便明确我们的意图。通过将break语句作为要忽略的案例的整个主体来编写。当该case与switch语句匹配时，case中的break语句立即结束switch语句的执行。

注意
仅包含注释的switch case会被报告为编译时错误。注释不是语句，也不会导致switch case被忽略。始终使用break语句来忽略switch case。

下面的示例是字符值的switch转换，来确定它是否表示四种语言之一的数字符号。为简洁起见，单个switch-case中包含多个值。

let numberSymbol: Character = "三"  // Chinese symbol for the number 3
var possibleIntegerValue: Int?
switch numberSymbol {
case "1", "١", "一", "๑":
    possibleIntegerValue = 1
case "2", "٢", "二", "๒":
    possibleIntegerValue = 2
case "3", "٣", "三", "๓":
    possibleIntegerValue = 3
case "4", "٤", "四", "๔":
    possibleIntegerValue = 4
default:
    break
}
if let integerValue = possibleIntegerValue {
    print("The integer value of \(numberSymbol) is \(integerValue).")
} else {
    print("An integer value couldn't be found for \(numberSymbol).")
}
// Prints "The integer value of 三 is 3."

本例检查numberSymbol以确定是否拉丁语、阿拉伯语、汉语还是泰语符号的数字1到4。如果找到匹配项，switch语句的一个case将设置名为possibleIntegerValue的可选的Int？变量为适当的整数值。

switch语句完成执行后，示例使用可选绑定来确定是否找到值。possibleIntegerValue变量由于是可选类型而具有一个隐式的初始值nil，因此只有在由switch语句的前四种情况之一设置possibleIntegerValue为实际值时，可选绑定才会成功。

因为在上面的例子中列出所有可能的Character值是不实际的，所以默认的case会处理任何不匹配的字符。这个默认情况不需要执行任何操作，因此它是用一个break语句作为主体编写的。一旦匹配了默认case，break语句就结束switch语句的执行，并且代码继续执行接下来的if let语句。

Fallthrough

在Swift中，switch语句不会从每个case的底部进入下一个case。也就是说，当第一个匹配的case完成时，整个switch语句就完成了它的执行。相比之下，C需要在每个switch case的末尾插入一个显式break语句，以防止出错。避免默认故障意味着Swift switch语句比C中的对应语句更加简洁和可预测，从而避免了错误地执行多个switch-case的情况。

如果我们需要C风格的fallthrough行为，我们可以使用fallthrough关键字根据具体情况选择此行为。下面的示例使用fallthrough创建数字的文本描述。

let integerToDescribe = 5
var description = "The number \(integerToDescribe) is"
switch integerToDescribe {
case 2, 3, 5, 7, 11, 13, 17, 19:
    description += " a prime number, and also"
    fallthrough
default:
    description += " an integer."
}
print(description)
// Prints "The number 5 is a prime number, and also an integer."

本例声明了一个名为description的新字符串变量，并为其指定了一个初始值。然后，该函数使用switch语句考虑integerToDescribe的值。如果integerToDescribe的值是列表中的素数之一，则函数会在描述的末尾追加文本，以说明该数字是素数。然后使用fallthrough关键字进入到默认情况。默认情况下，在描述的末尾添加一些额外的文本，switch语句就完成了。

除非integerToDescribe的值在已知素数列表中，否则它与第一个switch case根本不匹配。因为没有其他特定的情况，integerToDescribe将由默认情况匹配。

switch语句执行完毕后，将使用print(_:separator:terminator:)函数。在这个例子中，数字5被正确地识别为素数。

注意
fallthrough关键字不会检查它所引起执行进入的switch case的case条件。fallthrough关键字只会使代码执行直接移动到下一个case（或defaul-tcase）块中的语句，就像C的标准switch语句行为一样。

标记语句

在Swift中，可以在其他循环和条件语句中嵌套循环和条件语句，以创建复杂的控制流结构。但是，循环和条件语句都可以使用break语句提前结束它们的执行。因此，有时明确表示希望break语句终止的循环或条件语句非常有用。类似地，如果有多个嵌套循环，那么明确continue语句应该影响哪个循环也很有用。

为了达到这些目的，可以用语句标签标记循环语句或条件语句。对于条件语句，可以将语句标签与break语句一起使用，以结束已标记语句的执行。对于循环语句，可以将语句标签与break或continue语句一起使用，以结束或继续执行带标签的语句。

标记语句通过将标签放置在与语句的关键字相同的行上，后跟冒号来表示。下面是while循环的语法示例，尽管所有循环和switch语句的原理都是相同的：

截屏2021-02-23 下午2.53.46.png

下面的示例使用带有标签的while循环的break和continue语句来实现本章前面看到的蛇和梯子游戏的改编版本。这一次，游戏有一个额外的规则：

• 要想赢，你必须准确地降落在25号方格上。

如果某个骰子掷到25号方格以外，你必须再次掷骰，直到你掷到25号方格所需的确切数字为止。

游戏板和以前一样。

截屏2021-02-23 下午2.59.59.png

finalSquare、board、square和diceRoll的值的初始化方式与前面相同：

let finalSquare = 25
var board = [Int](repeating: 0, count: finalSquare + 1)
board[03] = +08; board[06] = +11; board[09] = +09; board[10] = +02
board[14] = -10; board[19] = -11; board[22] = -02; board[24] = -08
var square = 0
var diceRoll = 0

这个版本的游戏使用while循环和switch语句来实现游戏的逻辑。while循环有一个名为gameLoop的语句标签，表示它是蛇和梯子游戏的主游戏循环。

while循环的条件是while square != finalSquare，以反映我们必须准确地降落在25号方格上。

gameLoop: while square != finalSquare {
    diceRoll += 1
    if diceRoll == 7 { diceRoll = 1 }
    switch square + diceRoll {
    case finalSquare:
        // diceRoll will move us to the final square, so the game is over
        break gameLoop
    case let newSquare where newSquare > finalSquare:
        // diceRoll will move us beyond the final square, so roll again
        continue gameLoop
    default:
        // this is a valid move, so find out its effect
        square += diceRoll
        square += board[square]
    }
}
print("Game over!")

骰子在每个循环的开始处滚动。循环使用switch语句来考虑移动的结果并确定是否允许移动，而不是立即移动玩家：

• 如果掷骰子将玩家移到最后一个方块上，游戏就结束了。break gameLoop语句将控制转移到while循环之外的第一行代码，while循环会结束游戏。
• 如果掷骰将使玩家移动到最后一个方格之外，则该移动无效，玩家需要再次掷骰。continue gameLoop语句结束当前while循环迭代，并开始循环的下一次迭代。
• 在所有其他情况下，掷骰子是一个有效的举动。玩家通过掷骰子方块向前移动，游戏逻辑检查是否有蛇和梯子。然后循环结束，控制条件返回while条件以决定是否需要另一个回合。

注意
如果上面的break语句没有使用gameLoop标签，它将中断switch语句，而不是while语句。使用gameLoop标签可以明确应该终止哪个控制语句。

调用continue gameLoop以跳转到循环的下一个迭代时，不必严格使用gameLoop标签。游戏中只有一个循环，因此continue语句将影响哪个循环没有歧义。但是，在continue语句中使用gameLoop标签并没有什么坏处。这样做与break语句旁边的标签使用一致，有助于使游戏的逻辑更清晰地阅读和理解。

提前退出

像if语句一样，guard语句根据表达式的布尔值执行语句。我们可以使用guard语句来要求条件必须为true，以便执行guard语句之后的代码。与if语句不同，guard语句总是有else子句，如果条件不为true，则执行else子句中的代码。

func greet(person: [String: String]) {
    guard let name = person["name"] else {
        return
    }

    print("Hello \(name)!")

    guard let location = person["location"] else {
        print("I hope the weather is nice near you.")
        return
    }

    print("I hope the weather is nice in \(location).")
}

greet(person: ["name": "John"])
// Prints "Hello John!"
// Prints "I hope the weather is nice near you."
greet(person: ["name": "Jane", "location": "Cupertino"])
// Prints "Hello Jane!"
// Prints "I hope the weather is nice in Cupertino."

如果满足了guard语句的条件，将会执行在guard语句的右大括号之后的代码。在给任何变量或常量赋值时，都可以使用可选绑定作为条件的一部分出现在guard语句的代码块中。

如果不满足该条件，则执行else分支中的代码。该分支必须转移控制才能退出guard语句的代码块。它可以使用诸如return、break、continue或throw之类的控制传输语句来执行此操作进行控制转移，也可以调用不返回的函数或方法，例如fatalError(_:file:line:)..

与使用if语句进行相同的检查相比，对需求使用guard语句可以提高代码的可读性。它允许我们编写通常执行的代码，而无需将其包装在else块中，并且允许我们将违反条件要求的处理代码放在条件要求旁边。

检查API可用性

Swift内置了对检查API可用性的支持，这可以确保我们不会意外地对给定部署目标使用不可用的API。

编译器使用SDK中的可用性信息来验证代码中使用的所有API是否在项目指定的部署目标上可用。如果我们试图使用不可用的API，Swift会在编译时报告错误。

我们可以在if或guard语句中使用可用性条件来有条件地执行代码块，这取决于我们要使用的api在运行时是否可用。编译器在验证代码块中的api是否可用时，使用可用性条件中的信息。

if #available(iOS 10, macOS 10.12, *) {
    // Use iOS 10 APIs on iOS, and use macOS 10.12 APIs on macOS
} else {
    // Fall back to earlier iOS and macOS APIs
}

上面的可用性条件指定了，在iOS中，if语句的主体仅在ios10和更高版本中执行；在macOS中，仅在macos10.12和更高版本中执行。最后一个参数*是必需的，它指定在任何其他平台上，if的主体在目标指定的最小部署目标上执行。

在其一般形式中，可用性条件采用平台名称和版本的列表。在完整列表中使用诸如iOS、macOS、watchOS和tvOS等平台名称，请参见声明属性。除了指定主要版本号（如iOS 8或macOS 10.10）外，还可以指定次要版本号（如iOS 11.2.6和macOS 10.13.3）。

截屏2021-02-23 下午3.05.54.png