Swift编程语言学习4.1——周期

Swift它提供了类似 C 流量控制结构语言，它包含运行多个任务的能力for和while周期。选择根据不同的编码分支机构的具体条件来运行if和switch声明，有控制流程跳转到其他代码break和continue声明。

除了 C 语言里面传统的for条件递增（for-condition-increment）循环。Swift 还添加了for-in循环。用来更简单地遍历数组（array）。字典（dictionary），区间（range），字符串（string）和其它序列类型。

Swift 的switch语句比 C 语言中更加强大。在 C 语言中，假设某个 case不小心漏写了break，这个 case 就会贯穿（fallthrough）至下一个 case。Swift 无需写break，所以不会发生这样的贯穿（fallthrough）的情况。case 还能够匹配很多其它的类型模式。包含区间匹配（range matching）。元组（tuple）和特定类型的描写叙述。switch的 case 语句中匹配的值能够是由 case 体内部暂时的常量或者变量决定，也能够由where分句描写叙述更复杂的匹配条件。

For 循环

for循环用来依照指定的次数多次运行一系列语句。Swift提供两种for循环形式：

for-in用来遍历一个区间（range）。序列（sequence）。集合（collection），系列（progression）里面全部的元素运行一系列语句。

for条件递增（for-condition-increment）语句。用来反复运行一系列语句直到达成特定条件达成。一般通过在每次循环完毕后添加计数器的值来实现。

For-In

你能够使用for-in循环来遍历一个集合里面的全部元素，比如由数字表示的区间、数组中的元素、字符串中的字符。

以下的样例用来输出乘 5 乘法表前面一部分内容：

for index in 1...5 {
println("\(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）。之后println方法会再运行一次。

整个过程会进行到闭区间结尾为止。

上面的样例中。index是一个每次循环遍历開始时被自己主动赋值的常量。这样的情况下。index在使用前不须要声明。仅仅须要将它包括在循环的声明中。就能够对其进行隐式声明，而无需使用letkeyword声明。

注意：

index常量仅仅存在于循环的生命周期里。假设你想在循环完毕后訪问index的值，又或者想让index成为一个变量而不是常量，你必须在循环之前自己进行声明。

假设你不须要知道区间内每一项的值。你能够使用下划线（_）替代变量名来忽略对值的訪问：

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

这个样例计算 base 这个数的 power 次幂（本例中。是3的10次幂），从1（3的0次幂）開始做3的乘法，进行10次。使用0到9的半闭区间循环。这个计算并不须要知道每一次循环中计数器详细的值，仅仅须要运行了正确的循环次数就可以。下划线符号_（替代循环中的变量）可以忽略详细的值，而且不提供循环遍历时对值的訪问。

使用for-in遍历一个数组全部元素：

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

你也能够通过遍历一个字典来訪问它的键值对（key-value pairs）。遍历字典时，字典的每项元素会以(key, value)元组的形式返回，你能够在for-in循环中使用显式的常量名称来解读(key, value)元组。以下的样例中。字典的键（key）解读为常量animalName，字典的值会被解读为常量legCount：

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

字典元素的遍历顺序和插入顺序可能不同。字典的内容在内部是无序的，所以遍历元素时不能保证顺序。关于数组和字典，详情參见集合类型。

除了数组和字典，你也能够使用for-in循环来遍历字符串中的字符（Character）：

for character in "Hello" {
println(character)
}
// H
// e
// l
// l
// o

For条件递增（for-condition-increment）

除了for-in循环，Swift 提供使用条件推断和递增方法的标准 C 样式for循环:

for var index = 0; index < 3; ++index {
println("index is \(index)")
}
// index is 0
// index is 1
// index is 2

以下是普通情况下这样的循环方式的格式：

for `initialization`; `condition`;`increment` {
`statements`
}

和 C 语言中一样，分号将循环的定义分为 3 个部分。不同的是。Swift 不须要使用圆括号将“initialization; condition; increment”包含起来。

这个循环运行流程例如以下：

循环首次启动时。初始化表达式（initialization expression）被调用一次，用来初始化循环所需的全部常量和变量。

条件表达式（condition expression）被调用。假设表达式调用结果为false，循环结束，继续运行for循环关闭大括号（}）之后的代码。假设表达式调用结果为true。则会运行大括号内部的代码（statements）。

运行全部语句（statements）之后，运行递增表达式（increment expression）。

一般会添加或降低计数器的值。或者依据语句（statements）输出来改动某一个初始化的变量。当递增表达式运行完毕后，反复运行第 2 步，条件表达式会再次运行。

上述描写叙述和循环格式等同于：

`initialization`
while `condition` {
`statements`
`increment`
}

在初始化表达式中声明的常量和变量（比方var index = 0）仅仅在for循环的生命周期里有效。假设想在循环结束后訪问index的值，你必需要在循环生命周期開始前声明index。

var index: Int
for index = 0; index < 3; ++index {
println("index is \(index)")
}
// index is 0
// index is 1
// index is 2
println("The loop statements wereexecuted \(index) times")
// 输出 "The loopstatements were executed 3 times

注意index在循环结束后终于的值是3而不是2。

最后一次调用递增表达式++index会将index设置为3。从而导致index < 3条件为false，并终止循环。

While 循环

while循环执行一系列语句直到条件变成false。这类循环适合使用在第一次迭代前迭代次数未知的情况下。

Swift 提供两种while循环形式：

while循环。每次在循环開始时计算条件是否符合；

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

While

while循环从计算单一条件開始。假设条件为true，会反复执行一系列语句。直到条件变为false。

以下是普通情况下 while 循环格式：

while `condition` {
`statements`
}

以下的样例来玩一个叫做蛇和梯子（Snakes and Ladders）的小游戏。也叫做滑道和梯子（Chutes and Ladders）：

游戏的规则例如以下：

游戏盘面包含 25 个方格，游戏目标是达到或者超过第 25 个方格。

每一轮，你通过掷一个 6 边的骰子来确定你移动方块的步数。移动的路线由上图中横向的虚线所看到的；

假设在某轮结束。你移动到了梯子的底部。能够顺着梯子爬上去；

假设在某轮结束，你移动到了蛇的头部，你会顺着蛇的身体滑下去。

游戏盘面能够使用一个Int数组来表达。数组的长度由一个finalSquare常量储存，用来初始化数组和检測终于胜利条件。游戏盘面由 26 个 Int 0 值初始化，而不是 25 个（由0到25。一共 26 个）：

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

一些方块被设置成有蛇或者梯子的指定值。

梯子底部的方块是一个正值。使你能够向上移动。蛇头处的方块是一个负值。会让你向下移动：

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 {
// 掷骰子
if ++diceRoll == 7 { diceRoll = 1 }
// 依据点数移动
square += diceRoll
if square < board.count {
// 假设玩家还在棋盘上。顺着梯子爬上去或者顺着蛇滑下去
square += board[square]
}
}
println("Game over!")

本例中使用了最简单的方法来模拟掷骰子。 diceRoll的值并非一个随机数，而是以0为初始值，之后每一次while循环，diceRoll的值使用前置自增操作符(++i)来自增 1 。然后检測是否超出了最大值。

++diceRoll调用完毕后，返回值等于diceRoll自增后的值。不论什么时候假设diceRoll的值等于7时，就超过了骰子的最大值，会被重置为1。

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

掷完骰子后。玩家向前移动diceRoll个方格，假设玩家移动超过了第 25 个方格。这个时候游戏结束，对应地。代码会在square添加board[square]的值向前或向后移动（遇到了梯子或者蛇）之前，检測square的值是否小于board的count属性。

假设没有这个检測（square < board.count）。board[square]可能会越界訪问board数组，导致错误。比如假设square等于26， 代码会去尝试訪问board[26]，超过数组的长度。

当本轮while循环执行完成，会再检測循环条件是否须要再执行一次循环。

假设玩家移动到或者超过第 25 个方格，循环条件结果为false。此时游戏结束。

while 循环比較适合本例中的这样的情况。由于在while 循环開始时，我们并不知道游戏的长度或者循环的次数，仅仅有在达成指定条件时循环才会结束。

Do-While

while循环的第二种形式是do-while，它和while的差别是在推断循环条件之前，先运行一次循环的代码块，然后反复循环直到条件为false。

以下是普通情况下 do-while循环的格式：

do {
`statements`
} while `condition`

还是蛇和梯子的游戏，使用do-while循环来替代while循环。

finalSquare、board、square和diceRoll的值初始化同while循环一样：

let finalSquare = 25
var board = Int[](count: finalSquare + 1,repeatedValue: 0)
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

do-while的循环版本号，循环中第一步就须要去检測是否在梯子或者蛇的方块上。没有梯子会让玩家直接上到第 25 个方格，所以玩家不会通过梯子直接赢得游戏。这样在循环開始时先检測是否踩在梯子或者蛇上是安全的。

游戏開始时。玩家在第 0 个方格上。board[0]一直等于 0，不会有什么影响：

do {
// 顺着梯子爬上去或者顺着蛇滑下去
square += board[square]
// 掷骰子
if ++diceRoll == 7 { diceRoll = 1 }
// 依据点数移动
square += diceRoll
} while square < finalSquare
println("Game over!")

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

循环条项目（while square < finalSquare）和while一样的方法。但将仅在循环结束后计算。

在这场比赛中，do-while表现优于while更好的流通。do-while这样推断的条件square超过后无直接执行square += board[square]，可以以这样的方式去除while数组边界推理的版本号。