顺序结构

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

• 如果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 初始化语句; 循环条件; 迭代语句 { 循环体 }

• 这个循环执行流程如下：

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

  2. 条件表达式被调用，如果表达式调用结果为false，循环结束，继续执行for循环关闭大括号 (} )之后的代码。如果表达式调用结果为true，则会执行大括号内部的代码。

  3. 执行所有语句之后，执行递增表达式。通常会增加或减少计数器的值，或者根据语句输出来修改某一个初始化的变量。当递增表达式运行完成后，重复执行第 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) // 此句永远无法被执行
}