Swift学习笔记 (十一) 控制流(循环)

Swift 提供了多种流程控制结构，包括可以多次执行任务的 while 循环，基于特定条件选择执行不同代码分支的if 、 guard 和 

switch 语句，还有控制流程跳转到其他代码位置的 break 和 continue 语句。

Swift 还提供了 for-in 循环，⽤来更简单地遍历数组(Array)，字典(Dictionary)，区间(Range)，字符串 (String)和其他序列类

型。

Swift 的 switch 语句比许多类 C 语言要更加强大。case 还可以匹配很多不同的模式，包括范围匹配，元组(tuple) 和特定类型匹

配。 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) 元组的形式返回，你可以在 for-

in 循环中使用显式的常量名称来解读 (key, value) 元组。下⾯的例子中，字典的键声明为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 的数字区间。 index 被赋值为闭区间中的第一个数字( 1 )，

然后循环中的语句被执⾏一次。在本例中，这个循环只包含一个语句，⽤来输出当前 index 值所对应的乘 5 乘法表的结果。该语

句执⾏后， 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)")                      

// 输出“3 to the power of 10 is 59049”

 

这个例子计算 base 这个数的 power 次幂(本例中，是 3 的 10 次幂)，从 1 ( 3 的 0 次幂)开始做 3 的乘法， 进⾏ 10 次，使用 1 到 

10 的闭区间循环。这个计算并不需要知道每一次循环中计数器具体的值，只需要执⾏了正确的循环次数即可。下划线符号 _ (替

代循环中的变量)能够忽略当前值，并且不提供循环遍历时对值的访问。

在某些情况下，你可能不想使用包括两个端点的闭区间。想象一下，你在一个⼿表上绘制分钟的刻度线。总共 60 个刻度，从 0 

分开始。使用半开区间运算符( ..< )来表示一个左闭右开的区间。

let minutes = 60

for tickMark in 0..<minutes {

           // 每⼀一分钟都渲染一个刻度线(60次)

}

一些用户可能在其 UI 中可能需要较少的刻度。他们以每 5 分钟作为一个刻度。使用 stride(from:to:by:) 函数跳过不需要的标

记。

let minuteInterval = 5

for tickMark in stride(from: 0, to: minutes, by: minuteInterval) {

               // 每5分钟渲染一个刻度线(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) {

                // 每3⼩时渲染一个刻度线(3, 6, 9, 12)

}

 

While 循环

while 循环会一直运⾏一段语句直到条件变成 false 。这类循环适合使用在第一次迭代前，迭代次数未知的情况下。

Swift 提供两种 while 循环形式:

while 循环，每次在循环开始时计算条件是否符合;

repeat-while 循环，每次在循环结束时计算条件是否符合。

 

While

while 循环从计算一个条件开始。如果条件为 true ，会重复运⾏一段语句，直到条件变为 false 。 下⾯是 while 循环的一般格式:

while condition {

            statements

}

下⾯的例子来玩一个叫做蛇和梯子(也叫做滑道和梯子)的小游戏:

游戏的规则如下:

游戏盘面包括 25 个⽅格，游戏目标是达到或者超过第 25 个方格; 每一轮，你通过掷一个六面体骰子来确定你移动方块的步数，

移动的路线由上图中横向的虚线所示; 如果在某轮结束，你移动到了梯子的底部，可以顺着梯子爬上去；如果在某轮结束，你移

动到了蛇的头部，你会顺着蛇的身体滑下去。

游戏盘面可以使用一个 Int 数组来表达。数组的长度由一个 finalSquare 常量储存，用来初始化数组和检测最终胜利条件。游戏盘

面由 26 个 Int 0 值初始化，⽽不是 25 个(由 0 到 25 ，一共 26 个):

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 (来表示 11 和 3 之间的差值)。为了对齐语

句，这⾥使⽤了一元正运算符( +i )和一元负运算符( -i )，并且小于 10 的数字都使用 0 补齐 (这些语法的技巧不是必要的，只是为

了让代码看起来更加整洁)。

玩家由左下角空白处编号为 0 的方格开始游戏。玩家第一次掷骰子后才会进入游戏盘面:

var square = 0

var diceRoll = 0

while square < finalSquare {

// 掷骰⼦

diceRoll += 1

if diceRoll == 7 { diceRoll = 1 }// 根据点数移动

square += diceRoll

          if square < board.count {

                       // 如果玩家还在棋盘上，顺着梯子爬上去或者顺着蛇滑下去

                        square += board[square]

            }

}

print("Game over!")

本例中使用了最简单的⽅法来模拟掷骰子。 diceRoll 的值并不是一个随机数，⽽是以 0 为初始值，之后每一次while 循环， 

diceRoll 的值增加 1 ，然后检测是否超出了最⼤值。当 diceRoll 的值等于 7 时，就超过了骰子的最大值，会被重置为 1。所以 

diceRoll 的取值顺序会一直是 1，2，3，4，5，6，1，2 等。

掷完骰子后，玩家向前移动 diceRoll 个方格，如果玩家移动超过了第 25 个⽅格，这个时候游戏将会结束，为了应对这种情况，

代码会首先判断 square 的值是否小于 board 的 count 属性，只有小于才会在 board[square] 上增加 square ，来向前或向后移动

(遇到了梯子或者蛇)。

注意

如果没有这个检测( square < board.count )， board[square] 可能会越界访问 board 数组，导致运⾏时错误。

当本轮 while 循环运⾏完毕，会再检测循环条件是否需要再运⾏一次循环。如果玩家移动到或者超过第 25 个⽅格，循环条件结

果为 false ，此时游戏结束。

while 循环比较适合本例中的这种情况，因为在 while 循环开始时，我们并不知道游戏要跑多久，只有在达成指定条件时循环才会

结束。

 

Repeat-While

while 循环的另外一种形式是 repeat-while ，它和 while 的区别是在判断循环条件之前，先执⾏一次循环的代码块。然后重复循

环直到条件为 false 。

注意

Swift 语⾔的 repeat-while 循环和其他语言中的 do-while 循环是类似的。

下⾯是 repeat-while 循环的一般格式:

repeat {

            statements

} while condition

 

还是蛇和梯子的游戏，使用 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

repeat-while 的循环版本，循环中第一步就需要去检测是否在梯子或者蛇的方块上。没有梯子会让玩家直接上到第 25 个方格，

所以玩家不会通过梯子直接赢得游戏。这样在循环开始时先检测是否踩在梯⼦或者蛇上是安全的。

游戏开始时，玩家在第 0 个⽅格上， board[0] 一直等于 0， 不会有什么影响:

repeat {

// 顺着梯子爬上去或者顺着蛇滑下去

square += board[square]

// 掷骰子

diceRoll += 1

if diceRoll == 7 { diceRoll = 1 }

// 根据点数移动

square += diceRoll

} while square < finalSquare

print("Game over!")

 

检测完玩家是否踩在梯子或者蛇上之后，开始掷骰子，然后玩家向前移动 diceRoll 个⽅格，本轮循环结束。

循环条件( while square < finalSquare )和 while ⽅式相同，但是只会在循环结束后进⾏计算。在这个游戏中， repeat-while 表现

得比 while 循环更好。 repeat-while 方式会在条件判断 square 没有超出后直接运⾏ square += board[square] ，这种方式比起前

⾯ while 循环的版本，可以省去数组越界的检查。