Swift5.2-控制流(中文文档)

引言

继续学习Swift文档,从上一章节:集合类型,咱们学习了Swift集合相关的内容。如今,咱们学习Swift的控制流相关的内容。因为篇幅较长,这里分篇来记录,接下来,开始吧!html

若是你已经熟悉并掌握了条件控制相关内容,请参阅下一章节:函数swift

控制流

Swift提供了多种控制流语句。这些包括while循环来屡次执行一个任务;if、guard和switch语句根据特定条件执行不一样的代码分支;以及诸如break和continue这样的语句将执行流转移到代码中的另外一个点。数组

Swift还提供了一个for-in循环,能够方便地遍历数组、字典、范围、字符串和其余序列。安全

Swift的switch声明要比许多相似c语言的版本强大得多。用例能够匹配许多不一样的模式,包括间隔匹配、元组和特定类型的强制类型转换。switch案例中的匹配值能够绑定到临时常量或变量,以便在案例主体中使用,复杂的匹配条件能够用where子句表示。bash

1 For-in循环

可使用for-in循环迭代序列,例如数组中的项、数字范围或字符串中的字符。app

这个例子使用for-in循环来遍历数组中的项:ide

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

您还能够遍历字典来访问它的键-值对。在迭代字典时,字典中的每一个项都做为(键、值)元组返回,您能够将(键、值)元组的成员分解为显式命名的常量,以便在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
复制代码

字典的内容本质上是无序的,对它们进行迭代不能保证检索它们的顺序。特别是,向字典中插入条目的顺序并不定义迭代它们的顺序。有关数组和字典的更多信息,请参见集合类型oop

您还可使用具备数值范围的for-in循环。这个示例打印一个5次表中的前几项:post

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(包括5)的数字范围,如使用闭范围操做符(…)所示。index的值设置为范围(1)中的第一个数字,而后执行循环中的语句。在本例中,循环只包含一条语句,它从索引的当前值的五次表中打印一个条目。在执行语句后,index的值被更新为包含范围(2)中的第二个值,而且再次调用print(_:separator:terminator:)函数。这个过程一直持续到范围结束。

在上面的示例中,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(即3的0次方)乘以3,10次,使用从1开始到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)
}
复制代码

2 While循环

while循环执行一组语句,直到条件变为false为止。当在第一次迭代开始以前不知道迭代的数量时,最好使用这种类型的循环。Swift提供了两种while循环:

  • while 在每次遍历循环开始时计算其条件。
  • repeat-while——在每次循环结束时计算其条件。

2.1 While

while循环从计算单个条件开始。若是条件为真,则重复一组语句,直到条件为假。

下面是while循环的通常形式:

while condition {
    statements
}
复制代码

这个例子玩了一个简单的蛇和梯zi(掘金里面被定义为违规内容,因此用拼音代替)的游戏(也称为滑道和梯zi):

image.png
游戏规则以下:

  • 棋盘有25个方格,目标是落在或超过第25个方格。
  • 玩家的起始方块是“square zero”,它位于棋盘左下角。
  • 每一回合,你掷一个六面骰子,并移动该数目的方块,遵循水平路径指示,由上面的虚线箭头。
  • 若是你的回合结束在梯zi的底部,你就向上爬。
  • 若是你的回合结束在一条蛇的头部,你移动下那条蛇。

游戏板由Int值数组表示。它的大小基于一个名为finalSquare的常量,该常量用于初始化数组,并在本例中稍后检查win条件。由于玩家从棋盘开始,在“square zero”上,棋盘被初始化为26个0 Int值,而不是25。

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

一些方块会为蛇和梯zi设置更具体的值。有梯zi底座的方块有一个正数可让你在棋盘上向上移动,而蛇头的方块有一个负数可让你在棋盘上向下移动。

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包含梯zi的底部,它能够把你移动到正方形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。结果是一个diceRoll值序列,老是一、二、三、四、五、六、一、2等等。

滚动骰子后,玩家前进的diceRoll广场。有多是掷骰子把玩家移动到了25方,这样游戏就结束了。为了处理这种状况,代码检查正方形小于board数组的count属性。若是方块是有效的,存储在棋盘[方块]中的值将被添加到当前方块值中,以使玩家在任何梯zi或蛇上上下移动。

注意
若是这个检查没有执行,board[square]可能会尝试访问一个超出board数组边界的值,这将触发一个运行时错误。

此时,当前while循环执行结束,并检查循环的条件,以肯定是否应该再次执行该循环。若是玩家已经移动到或超过了平方数25,循环的条件将计算为false,游戏结束。

在这种状况下使用while循环是合适的,由于游戏的长度在while循环开始时并不清楚。相反,循环将一直执行到知足特定条件为止。

2.2 Repeat-While

while循环的另外一个变体,称为repeat-while循环,在考虑循环条件以前,会先执行一次循环循环。 而后,它将继续repeat-while循环,直到条件为假。

注意
Swift中的repeat-while循环相似于其余语言中的do-while循环。

这是repeat-while循环的通常形式:

repeat {
    statements
} while condition
复制代码

这又是“蛇和梯zi”示例,写为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
复制代码

在此版本的游戏中,循环中的第一个动做是检查梯zi或蛇。 棋盘上没有梯zi可以使玩家直奔25格,所以不可能经过爬梯zi来赢得比赛。 所以,安全地检查蛇或梯zi是循环中的第一步。

在游戏开始时,玩家处于“零平方”。 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!")
复制代码

代码检查完蛇和梯zi后,掷骰子,并由diceRoll方块使玩家向前移动。 而后,当前循环执行结束。

循环的条件(square<finalSquare时)与之前相同,可是此次直到循环的第一次运行结束时才进行评估。 与以前示例中的while循环相比,repeat-while循环的结构更适合此游戏。 在上面的repeat-while循环中,square+ = board [square]老是在循环的while条件确认正方形仍在板上后当即执行。 此行为消除了对前面所述游戏的while循环版本中看到的数组边界检查的须要。

3 条件语句

根据某些条件执行不一样的代码段一般颇有用。 您可能想在发生错误时运行额外的代码,或者在值变得太大或过低时显示一条消息。 为此,您须要将部分代码做为条件。

Swift提供了两种向代码中添加条件分支的方法:if语句和switch语句。 一般,您使用if语句评估只有少数可能结果的简单条件。 switch语句更适合于具备多个可能排列的更复杂条件,而且在模式匹配能够帮助选择合适的代码分支来执行的状况下颇有用。

3.1 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条件为false,则if语句能够提供另外一组语句,称为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 or else if条件,因此不会打印任何消息。

3.2 Switch

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

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

switch some value to consider {
case value 1:
    respond to value 1
case value 2,
     value 3:
    respond to value 2 or 3
default:
    otherwise, do something else
}
复制代码

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

就像if语句的主体同样,每种状况都是代码执行的单独分支。 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语句的第一个字母与英文字母的第一个字母a匹配,第二个字母与最后一个字母z匹配。 由于switch必须为每一个可能的字符而不是每一个字母字符都具备case,因此该switch语句使用默认的case来匹配除a和z以外的全部字符。 此规定确保switch语句是详尽无遗的。

3.3 无需隐式的Fallthrough

与C和Objective-C中的switch语句相比,Swift中的switch语句不会执行到每种状况的底部,默认状况下不会执行下一种状况。 相反,整个switch语句将在第一个匹配的switch状况完成后当即完成其执行,而无需显式的break语句。 这使得switch语句比C语言中的语句更安全和易于使用,而且避免了错误执行多个switch状况。

注意
尽管在Swift中不须要break,可是您可使用break语句来匹配和忽略特定的状况,或者在该状况完成执行以前从匹配的状况中中断。 有关详细信息,请参见Break in a Switch Statement

每一个案例的主体必须至少包含一个可执行语句。 编写如下代码是无效的,由于第一种状况为空:

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.
复制代码

注意
OC能够这么写,不会编译报错。

与C中的switch语句不一样,此switch语句不一样时匹配“ a”和“ A”。 而是,报告一个编译时错误,状况为“ a”:不包含任何可执行语句。 这种方法避免了从一个案例到另外一个案例的意外失败,并使意图更清晰,代码更安全成为可能。

要使用同时匹配“ a”和“ A”的单个case进行切换,请将两个值组合为复合case,并用逗号分隔这些值。

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

为了便于阅读,还能够将多行案例写在多行上。 有关复合案例的更多信息,请参见复合案例

注意
要在特定切换条件的末尾显式的Fallthrough,请使用fallthrough关键字,如Fallthrough中所述。

3.4 间隔匹配

能够检查切换案例中的值是否包含在间隔中。 本示例使用数字间隔为任意大小的数字提供天然语言计数:

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."
复制代码

在上面的示例中,在switch语句中计算了近似计数。 每种状况都会将该值与一个数字或间隔进行比较。 因为近似计数的值介于12到100之间,所以为naturalCount分配了"dozens of"值,而且将执行转移到switch语句以外。

3.5 元组

您可使用元组在同一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"
复制代码

switch语句肯定点是在原点(0,0),在红色x轴上,在橙色y轴上,在以原点为中心的蓝色4 x 4框内仍是在框外 。

与C不一样,Swift容许多个switch cases判断相同的一个或多个值。 实际上,在此示例中,点(0,0)能够匹配全部四种状况。 可是,若是可能有多个匹配项,则始终使用第一个匹配状况。 点(0,0)首先匹配case(0,0),所以全部其余匹配cases都将被忽略。

3.6 值绑定

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"
复制代码

switch语句肯定该点是在红色的x轴上,在橙色的y轴上仍是在其余位置(均不在两个轴上)。

这三个switch case声明了占位符常量x和y,它们暂时采用来自anotherPoint的一个或两个元组值。 第一种状况为case(let x,0),它匹配y值为0的任何点,并将该点的x值分配给临时常数x。 一样,第二种状况,即状况(0,设y),匹配x值为0的任何点,并将该点的y值分配给临时常数y。

声明临时常量后,能够在案例的代码块中使用它们。 在这里,它们用于打印点的分类。

该switch语句没有默认状况。 最后一种状况,即let(x,y),声明了两个能够匹配任何值的占位符常量的元组。 由于anotherPoint始终是两个值的元组,因此这种状况与全部可能的剩余值匹配,而且不须要缺省状况来使switch语句穷举。

3.7 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"
复制代码

switch语句肯定该点是在x == y的绿色对角线上,在x == -y的紫色对角线上仍是在这两个点上。

这三个switch case声明了占位符常量x和y,它们分别采用了yetAnotherPoint中的两个元组值。 这些常量用做where子句的一部分,以建立动态过滤器。 仅当where子句的条件评估为该值时,switch case才匹配point的当前值。

与前面的示例同样,最终状况匹配全部可能的剩余值,所以不须要默认状况来使switch语句穷举。

3.8 复合Cases

共享同一主体的多个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) is not a vowel or a consonant")
}
// Prints "e is a vowel"
复制代码

switch语句的首字母大写与英语中的全部五个小写元音匹配。 一样,它的第二种状况匹配全部小写的英语辅音。 最后,默认大小写匹配任何其余字符。

复合案例还能够包括值绑定。 复合案例的全部模式都必须包含相同的值绑定集,而且每一个绑定必须从复合案例的全部模式中获取相同类型的值。 这样能够确保,不管复合案例的哪一部分匹配,案例主体中的代码始终能够访问绑定的值,而且该值始终具备相同的类型。

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"
复制代码

上面的状况有两种模式:(let distance,0)匹配x轴上的点,(0,let distance)匹配y轴上的点。 两种模式都包含distance的绑定,而且两种模式中的distance都是整数,这意味着案例主体中的代码始终能够访问distance值。

4 控制转移语句

经过将控制权从一个代码段转移到另外一个代码段,控制转移语句改变了代码执行的顺序。 Swift有五个控制转移语句:

continue
break
fallthrough
return
throw
复制代码

continue、break和fallthrough语句描述以下。return语句的描述在 Functions里,throw语句能够参见Propagating Errors Using Throwing Functions

4.1 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关键字,从而致使循环的当前迭代当即结束并直接跳至下一个迭代的开始。

4.2 Break

break语句当即结束整个控制流语句的执行。 当您要比其余状况更早地终止switch或loop语句的执行时,能够在switch或loop语句内使用break语句。

4.2.1 循环语句里的Break

在循环语句中使用break时,会当即结束循环的执行,并在循环的右括号(})以后将控制权转移给代码。 不会执行循环的当前迭代中的其余代码,也不会启动循环的其余迭代。

4.2.2 Switch语句里的Break

在switch语句内使用break时,会致使switch语句当即结束其执行,并将控制权转移到switch语句的右括号(})以后。

此行为可用于匹配和忽略switch语句中的一个或多个状况。 因为Swift的switch语句是详尽无遗的,而且不容许空白的案例,所以有时有必要故意匹配并忽略案例,以使意图明确。 您能够经过将break语句做为要忽略的案例的总体来编写。 当该案例与switch语句匹配时,案例内的break语句将当即终止switch语句的执行。

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

下面的示例打开一个Character值,并肯定它是否表明四种语言之一的数字符号。 为简便起见,在一个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 could not be found for \(numberSymbol).")
}
// Prints "The integer value of 三 is 3."
复制代码

本示例检查numberSymbol以肯定数字1到4是拉丁,阿拉伯,中文仍是泰文符号。若是找到匹配项,则switch语句的一种状况将设置可选的Int? 变量,可能为一个可选的整数值。

在switch语句完成执行以后,该示例使用可选绑定来肯定是否找到了值。 PossibleIntegerValue变量是可选类型,所以具备隐式初始值nil,所以,只有在switch语句的前四种状况之一将可能性IntegerValue设置为实际值时,可选绑定才会成功。

因为在上面的示例中列出全部可能的Character值不切实际,所以默认状况下会处理全部不匹配的字符。 此默认状况不须要执行任何操做,所以它以单个break语句为主体编写。 匹配默认大小写后,break语句将结束switch语句的执行,而且代码将从if let语句继续执行。

4.3 Fallthrough

在Swift中,switch语句不会落入每种状况的底部,也不会落入下一种状况。 即,第一个匹配的状况一旦完成,整个switch语句就完成其执行。 相比之下,C要求您在每一个switch状况的末尾插入一个显式的break语句,以防止失败。 避免默认的失败,意味着Swift的switch语句比C语言中的对应语句更加简洁和可预测,所以避免了错误地执行多个switch状况。

若是您须要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的新String变量,并为其分配一个初始值。 而后,该函数使用switch语句判断integerToDescribe的值。 若是integerToDescribe的值是列表中的质数之一,则该函数会将文本追加到描述末尾,以指出该数字是质数。 而后,它也使用fallthrough关键字来“落入”默认大小写。 默认状况下,在描述末尾添加了一些额外的文本,而且switch语句已完成。

除非integerToDescribe的值在已知质数列表中,不然第一个switch case根本不匹配。 由于没有其余特定状况,因此integerToDescribe与默认状况匹配。 在switch语句执行完以后,使用print(_:separator:terminator :)函数打印号码的描述。 在此示例中,数字5被正确标识为质数。

注意
fallthrough关键字不检查致使执行陷入的switch case的条件。 fallthrough关键字仅致使代码执行直接移至下一个case(或默认case)块内的语句,就像C的标准switch语句行为同样。

4.4 Labeled语句

在Swift中,您能够将循环和条件语句嵌套在其余循环和条件语句中,以建立复杂的控制流结构。 可是,循环和条件语句均可以使用break语句提早结束执行。 所以,有时对于明确要让break语句终止的循环或条件语句颇有用。 一样,若是您有多个嵌套循环,则明确说明continue语句应该影响哪一个循环会颇有用。

为了实现这些目标,可使用语句label标记循环语句或条件语句。 对于条件语句,能够将语句label与break语句一块儿使用以结束带label的语句的执行。 对于循环语句,能够将语句label与break或continue语句一块儿使用,以结束或继续执行带label的语句。

带label的语句是经过在与该语句的介绍者关键字相同的行上放置一个标签来表示的,后跟一个冒号。 这是一个while循环的语法示例,尽管原理对于全部循环和switch语句都是相同的:

label name: while condition {
    statements
}
复制代码

下面的示例使用带有label的while循环的break和continue语句,为您在本章前面介绍的Snakes and Ladders游戏的改编版提供帮助。 此次,游戏有一个额外的规则:

  • 为了赢,您必须准确落在25号square上。

若是特定骰子掷骰使您超过25号方格,则必须再次掷骰,直到掷出准确的数字才能落在25号方格上。

游戏板与之前相同。

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的语句标签,以指示它是Snakes and Ladders游戏的主要游戏循环。

while循环的条件是while方格== 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循环以外的第一行代码,从而结束了游戏。
  • 若是掷骰子会将玩家移出最终方块,则该移动无效,玩家须要再次掷骰子。 Continue gameLoop语句结束当前的while循环迭代并开始循环的下一个迭代。 在全部其余状况下,掷骰子都是有效的举动。
  • 玩家以diceRoll方块向前移动,游戏逻辑检查是否有蛇和梯zi。 而后循环结束,控制返回while条件,以决定是否须要再转一圈。

注意
若是上面的break语句不使用gameLoop标签,它将脱离switch语句,而不是while语句。 使用gameLoop标签能够清楚地代表应该终止哪一个控制语句。

调用continue gameLoop跳转到循环的下一个迭代时,不必定必须使用gameLoop标签。 游戏中只有一个循环,所以,继续声明会影响哪一个循环没有任何歧义。 可是,将gameLoop标签与continue语句一块儿使用不会有任何危害。 这样作与标签在break语句旁边的用法一致,并有助于使游戏的逻辑更易于阅读和理解。

5 提早退出(guard)

与if语句同样,guard语句根据表达式的布尔值执行语句。 您使用保护语句要求条件必须为true,以便执行保护语句以后的代码。 与if语句不一样,guard语句始终具备else子句-若是条件不成立,则执行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块中,并使处理违反要求的代码保持在要求旁边。

6 检查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语句的主体仅在iOS 10及更高版本中执行; 在macOS中,仅在macOS 10.12及更高版本中。 最后一个参数*是必需的,它指定在任何其余平台上,if的主体在目标所指定的最小部署目标上执行。

在通常状况下,可用性条件采用平台名称和版本的列表。 您使用平台名称,例如iOS,macOS,watchOS和tvOS,有关完整列表,请参阅Declaration Attributes。 除了指定主要版本号(例如iOS 8或macOS 10.10)以外,您还能够指定次要版本号(例如iOS 11.2.6和macOS 10.13.3)。

if #available(platform name version, ..., *) {
    statements to execute if the APIs are available
} else {
    fallback statements to execute if the APIs are unavailable
}
复制代码

总结

这一章节学习的内容在这里作个总结:

  • for-in循环:能够直接声明变量来做为数组循环的返回值,或使用元组来做为字典循环的返回值,或者使用通配符_来忽略值;还可使用...和..<来进行范围循环;还可使用stride(from:to:by:)函数老跳过不须要的标记循环。
  • while循环:有两种while和repeat-while(相似C语言中的do-while)循环。
  • if条件语句,这个你们应该都会,这里不作赘述。
  • switch语句,swift里的和OC里的不同,switch判断的值能够是任何类型,不像OC只能匹配整型,在swift里在一个case末尾不须要加break来跳出switch case,默认会直接结束switch case的判断;switch能够用间隔匹配的功能,如:case 1..<5:来匹配一个范围的值;还可使用元组,如:case (0, 0)、case(_, 0)、case(0, _)、case(-2...2, -2...2)来匹配多个值;还可使用值绑定,如:case (let x, 0)、case(0, let y)、case(let x, let y)来匹配一个或多个值;还可使用where关键字来添加条件判断,如:case let (x, y) where x== y;还能够在case后加入多个模式,如:case "a","e","i"
  • 控制转移语句:continue、break,swift里的和OC的用法差很少;swift多出的功能是fallthrough和带标签语句。使用fallthrough来使switch语句能继续执行下一个case内的内容;使用带标签的语句,配合switch语句和break、contine判断带标签的变量是否知足条件,具体的实现能够看上面的代码。
  • guard语句,功能和if语句同样,不过用guard语句条件判断会更高效,且代码更简洁。
  • 检查API可用性,可配合if和guard语句使用,如:if #available(platform name version, ..., *)

上一章节:集合类型

下一章节:函数

参考文档:Swift - Control Flow

相关文章
相关标签/搜索