Swift - 流程控制

顺序结构

任何编程语言中最常见的程序结构就是顺序结构。顺序结构就是程序从上到下一行一行地执行，中间没有任何判断和跳转。

如果Swift程序的多行代码之间没有任何流程控制，则程序总是从上向下一次执行，排在前面的代码先执行，排在后面的代码后执行，这意味着：如果没有流程控制，Swift程序的语句是一个顺序执行流，从上向下一次执行每条语句。

分支结构

Swift提供了两种常见的分支控制结构，

if

语句和

switch

语句，其中

if

语句使用布尔表达式或者布尔值作为分支条件来进行分支控制，而

switch

语句则更使用与更为复杂的条件。

一般来说，当条件较为简单且可能的情况较少的时候，使用

if

语句；当条件比较复杂并且情况很多的时候，使用

switch

语句。

if条件语句

if

语句可以使用任意表达式作为分支条件来进行分支控制。

if

语句有如下三种形式：

// 1、第一种形式
if expression {
    statements...
}

// 2、第二种形式
if expression { 
    statements...  
}else {
    statements... 
}

// 3、第三种形式
if expression {
    statements...   
}else if expression {
    statements...    
}else {    
    statements...    
}

if

语句最简单的形式就是只包含一个条件，当且仅当该条件为

true

时，才执行相关代码：

var isLogin = true

if isLogin {
    print("已登录！")
}

// 输出 已登录

if-else

，当程序判断

if

条件为假时将会执行

else

语句：

var isLogin = false

if isLogin {
    print("已登录！")
}else {
    print("未登录！")
}

// 输出 未登录！

当程序需要判断多个条件时可使用

if-else if-else

语句：

var score = 90

if score >= 90 {
    print("优秀")
}else if score >= 70 {
    print("及格")
}else {
    print("一般")
}

// 输出 优秀

上述例子中，根据分数的不同评定成绩，第一个

if

判断如果成绩大于等于90分，则执行输出优秀语句；第二个

if

判断如果成绩大于等于70分，则执行输出及格语句；最后的一个

else

，则代表小于70分的成绩，执行输出一般语句。值得注意的是，最后的

else

语句是可选的。

switch分支语句

switch

语句由一个控制表达式和多个

case

标签组成。

switch

语句会尝试把某个值与若干个模式进行匹配。根据第一个匹配成功的模式，

switch

语句会执行对应的代码。

switch

的语法格式如下：

switch expression {
case value1:
    statements...
case value2, value3:
    statements...
case valueN:
    statements...
default:
    statements...
}

这种分支语句的执行是先对

expression

求值，然后一次匹配value1、value2、value3…valueN等值，遇到匹配的值即执行对应的执行体；如果所有

case

标签后的值都不与

expression

表达式的值相等，则执行

default

标签后的代码块。

上述语法格式第二个

case

当中可以看出，

switch

语句的任意一个

case

标签都可以紧跟多个值，这样一个

case

块就可以匹配多个值了。

var score = "C"

// 执行switch分支语句
switch score {
    case "A":
        print("优秀")
    case "B", "C":
        print("良好")
    case "D":
        print("及格")
    case "E":
        print("不及格")
default:
    print("输入错误")
}

// 输出 良好

不存在隐式贯穿

与 C 语言和 Objective-C 中的

switch

语句不同，在 Swift 中，当匹配的

case

分支中的代码执行完毕后，程序会终止

switch

语句，而不会继续执行下一个

case

分支。这也就是说，不需要在

case

分支中显式地使用

break

语句。这使得

switch

语句更安全、更易用，也避免了因忘记写 break 语句而产生的错误。

注意：虽然在Swift中

break

不是必须的，但你依然可以在

case

分支中的代码执行完毕前使用

break

跳出。

每一个

case

分支都必须包含至少一条语句。像下面这样书写代码是无效的，因为第一个 case 分支是空的：

let score = "A"

switch score {
    case "A":
    case "a":
        print("优秀")
    case "B":
    case "b":
        print("良好")
    case "C":
    case "c":
        print("及格")
    case "D":
    case "d":
        print("不及格")
default:
    print("输入错误")
}

不像 C 语言里的

switch

语句，在 Swift 中，

switch

语句不会同时匹配

"a"

和

"A"

。相反的，上面的代码直接导致编译期错误:

case "a": does not contain any executable statements

——这就避免了意外地从一个

case

分支贯穿到另外一个，使得代码更安全、也更直观。

实际上，swift 为上面这种需求提供了更便捷的语法：swift 的

case

标签后可紧跟多个值，这样每个

case

块都可以匹配多个值，因此只要把程序改为如下形式即可：

let score = "A"

switch score {
    case "A", "a":
        print("优秀")
    case "B", "b":
        print("良好")
    case "C", "c":
        print("及格")
    case "D", "d":
        print("不及格")
default:
    print("输入错误")
}

注意：如果想要贯穿至特定的

case

分支中，请使用

fallthrough

语句。

区间匹配

-

switch

语句的

case

块后的条件可以是一个范围。

let score = 90

switch score {
    case 90...100:
        print("优秀")
    case 70..<90:
        print("良好")
    case 60..<70:
        print("及格")
    case 0..<60:
        print("不及格")
default:
    print("成绩错误")
}

// 输出 优秀

上面程序中的 switch 语句的

case

块后的条件使用了范围运算符指定值的范围，这样只要 switch 表达式的值落入指定范围，那么程序就会执行对应的

case

块。

元组匹配

switch

语句支持使用元组匹配多个值，

case

后面的元组既可以是单独的值，也可以是特定的范围；另外，可以在范围中使用（

_

）来匹配所有可能的值。

循环结构

循环语句可以在满足循环条件的情况下，反复执行每一段代码，这段被重复执行的代码被成为循环体。当反复执行这个循环体时，需要在合适的时候把循环条件改为假，从而结束循环，否则循环将一直执行下去，形成死循环。循环语句一般包含四个部分：初始化语句、循环条件、循环体以及迭代语句。

For循环

Swift 提供两种 for 循环形式以来按照指定的次数多次执行一系列语句:

for-in

循环对一个集合里面的每个元素执行一系列语句。

for

循环，用来重复执行一系列语句直到达成特定条件达成，一般通过在每次循环完成后增加计数器的值来实 现。

for-in循环

使用

for-in

循环来遍历一个集合里面的所有元素，例如由数字表示的区间、数组中的元素、字符串中的字符。

for-in

循环的语法格式为：

for (let/var) 常量/变量名/_ in 字符串/范围/集合 {
    statements...
}

注意：

1、

for-in

循环中的常量无需声明。

for-in

循环中的常量将会在每次循环开始时自动被赋值，因此该常量无需提前声明，只要将它包含在

for-in

循环的声明中，即可隐式声明该常量，无需使用

let

关键字声明，如果定义成变量，则需使用

var

关键字声明


2、如果循环体内无需访问正在遍历的元素的值，程序可使用下划线(

_

)代替常量名来忽略访问元素的值。

// 1、遍历范围
for var index in 1...5 {
    print("\(index) * 5 = \(index * 5)")
}

// 1 * 5 = 5
// 2 * 5 = 10
// 3 * 5 = 15
// 4 * 5 = 20
// 5 * 5 = 25

// 2、遍历数组
let cards = ["A", "K", "Q", "J"]

for card in cards {
    print(card)
}

// 依次输出：A、K、Q、J

// 3、遍历字符串
let string = "Swift"
for ch in string.characters {
    print(ch)
}
// 依次输出：S、w、i、f、t

// 4、忽略元素遍历
for _ in "ABC".characters {
    print("忽略元素遍历")
}

// 忽略元素遍历
// 忽略元素遍历
// 忽略元素遍历

for循环

除了

for-in

循环，Swift 提供使用条件判断和递增方法的标准 C 样式

for

循环，其格式为：

for 初始化语句; 循环条件; 迭代语句 {
    循环体
}

这个循环执行流程如下：

循环首次启动时，初始化表达式被调用一次，用来初始化循环所需的所有常量和变量。

条件表达式被调用，如果表达式调用结果为

false

，循环结束，继续执行

for

循环关闭大括号 (

}

)之后的代码。如果表达式调用结果为

true

，则会执行大括号内部的代码。

执行所有语句之后，执行递增表达式。通常会增加或减少计数器的值，或者根据语句输出来修改某一个初始化的变量。当递增表达式运行完成后，重复执行第 2 步，条件表达式会再次执行。

// 使用循环计算计算0~100的和

var sum = 0

for var i = 0; i <= 100; i++ {
    sum += i
}

print("sum is '\(sum)'.") // 输出 sum is '5050'.

While循环

while

循环运行一系列语句直到条件变成

false

。这类循环适合使用在第一次迭代前迭代次数未知的情况下。Swift 提供两种

while

循环形式：

while

循环，每次在

循环开始时

计算条件是否符合；

Repeat-While

循环，每次在

循环结束时

计算条件是否符合。

While循环

while

循环的语法格式如下：

初始化语句
while 循环条件 {
    循环体
    迭代语句
}

while

循环在每次执行循环体之前，先对循环条件求值，如果循环条件为

true

，则运行循环体部分，从上面的语法格式来看，迭代语句总是位于循环体的最后，因此只有当循环体能成功执行时，

while

循环才会执行迭代语句。

// 1、初始化语句
var sum = 0
var index = 0

// 2、循环条件
while index <= 100 {
    // 3、循环体
    sum += index
    // 4、迭代语句
    index++
}

print("sum is '\(sum)'.") // 输出 sum is '5050'.

Repeat-While循环

repea-while

循环的语法格式如下：

初始化语句
repeat {
    循环体
    迭代语句
}while 循环条件

repeat-while

循环与

while

循环的区别在于：

while

循环是先判断循环条件，如果条件为

true

才执行循环体；而

repeat-while

循环则先执行循环体，然后才判断循环条件，如果循环条件为

true

，则执行下一次循环，否则终止循环。

var index = 0

repeat {
    sum += index
    index++
}while index <= 100

print("sum is '\(sum)'.") // 输出 sum is '5050'.

控制转移语句

控制转移语句改变你代码的执行顺序,通过它你可以实现代码的跳转。Swift有四种控制转移语句：

continue

、

break

、

fallthrough

、

return

、

throw

。

continue

continue

语句告诉一个循环体立刻停止

本次

循环迭代，重新开始下次循环迭代。

for flag in 1...5 {

    if flag == 3 {
        continue
    }

    print("current index is '\(flag)'.")
}

// current index is '1'.
// current index is '2'.
// current index is '4'.
// current index is '5'.

上述例子中，

if

语句判断当

flag == 3

的时候，

continue

结束本次循环继续执行下一次循环，因此，打印语句中没有打印

3

。

break

当在一个循环体中使用

break

时,会立刻中断该循环体的执行，然后跳转到表示循环体结束的大括号(

}

)后的第一行代码。不会再有本次循环迭代的代码被执行，也不会再有下次的循环迭代产生。

for var k = 0; k < 5; k++ { 
    if k == 3 {
        break
    } 
    print("k is '\(k)'.")
}

// k is '0'.
// k is '1'.
// k is '2'.

上述例子中，

if

语句判断当

flag == 3

的时候，

break

结束循环。

fallthrough

Swift 中的

switch

不会从上一个

case

分支落入到下一个 case 分支中。相反，只要第一个匹配到的

case

分支完成了它需要执行的语句，整个

switch

代码块完成了它的执行。相比之下，C 语言要求你显示的插入

break

语 句到每个

switch

分支的末尾来阻止自动落入到下一个

case

分支中。Swift 的这种避免默认落入到下一个分支中的特性意味着它的

switch

功能要比 C 语言的更加清晰和可预测，可以避免无意识地执行多个

case

分支从而引发的错误。

如果你确实需要 C 风格的贯穿的特性，你可以在每个需要该特性的

case

分支中使用

fallthrough

关键字。

var tag = 0
var results: String = String()

switch tag {
    case 0:
        results += "A"
        print(results)
        fallthrough

    case 1:
        results += "B"
        print(results)
        fallthrough

default:
    results += "C"
    print(results)
}

// A
// AB
// ABC

注意：

fallthrough

关键字不会检查它下一个将会落入执行的

case

中的匹配条件。

fallthrough

简单地使代码执行继续连接到下一个

case

中的执行代码这和 C 语言标准中的

switch

语句特性是一样的。

return

return

关键字并不是专门用于结束循环的，

return

的功能是结束一个函数或方法。

func test() {
    var i = 0
    i++

    return   // 结束方法（函数）

    print(i) // 此句永远无法被执行
}