Swift提供了多种流程控制结构，包括可以多次执行任务的while循环，基于特定条件基于特定条件选择执行不同代码分支的ifguardswitch语句，还有控制流程跳转到其他代码位置的breakcontinue语句 Swift还提供了for-in循环，用来更简单的遍历数组 (Array),字典(Dictionary),集合(Set)，区间 (Range)，字符串 (String)和其他序列类型 Swift的switch语句比c语言中更加强大，case还可以匹配很多不同的模式，包括范围匹配，元组和特定类型匹配，switch语句的case中匹配的值可以声明为临时常量或变量，在case作用域内使用，也可以匹配where`来描述更复杂的匹配条件

For-in

//遍历数组
let arr1 = ["i","am","a","good","boy"]
for arr1Str in arr1 {
    print("arr1Str:\(arr1Str)")
}
/*
 arr1Str:i
 arr1Str:am
 arr1Str:a
 arr1Str:good
 arr1Str:boy
 */

//遍历集合
let set1:Set = [1,2,3,4,5]
for set1Int in set1 {
    print("set1Int:\(set1Int)")
}
/*
 set1Int:5
 set1Int:2
 set1Int:3
 set1Int:1
 set1Int:4
 */

//遍历字典
let dic1 = [1:"1",2:"2",3:"3"]
for (dicKey,dicValue) in dic1 {
    print("dicKey:\(dicKey) dicValue:\(dicValue)")
}
/*
 dicKey:2 dicValue:2
 dicKey:3 dicValue:3
 dicKey:1 dicValue:1
 */

//遍历字符串
let str1 = "iamagoodboy"
for str1Ch in str1 {
    print("str1Ch:\(str1Ch)")
}
/*
 str1Ch:i
 str1Ch:a
 str1Ch:m
 str1Ch:a
 str1Ch:g
 str1Ch:o
 str1Ch:o
 str1Ch:d
 str1Ch:b
 str1Ch:o
 str1Ch:y
*/

//循环数字范围
for idx in 1...5 {
    print("\(idx) times 5 is \(idx*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
 */

While

while循环会一直运行一段语句直到条件变成false

条件只能为true和false,oc中只要为正数也可能表示条件为true，swift中不行
这类循环适合使用在第一次迭代前，迭代次数未知的情况下。Swift 提供两种while循环形式

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

var whileI:Int = 10
while whileI > 0 {
    print("whileI:\(whileI)")
    whileI -= 1
    //--whileI 在swift废除了？？？？？
}
/*
 whileI:10
 whileI:9
 whileI:8
 whileI:7
 whileI:6
 whileI:5
 whileI:4
 whileI:3
 whileI:2
 whileI:1
 */

• repeat-while循环，每次在循环结束时计算条件是否符合，意思就是说：它和while的区别是在判断循环条件之前，先执行一次循环的代码块。然后重复循环直到条件为false，可以相当于oc中的do-while

//Repeat-While

var whilerR = false
repeat{
    print("whilerR")
}while whilerR
/*
 whilerR 
 先进去statements再判断下次是否进入
 */

if

if语句是最简单的形式，只包含一个条件，只有该条件为true，才执行相关代码

注意，跟while的条件判断是一样，swift下的条件判断只有true和false，正整数并不能表示true

Switch

oc中的switch的参数类型要求是integer type，如果不是integer就会报错Statement requires expression of integer type ('NSString *__strong' invalid)
oc中的case 语句是为了匹配switch中的参数的值，所以其条件值必须是常数(const)

image.png

下面来说了swift中的switch

let switchT1 = 1
switch switchT1 {
case 1:
    print("switchT1 == 1")
default:
    print("switchT1 != 1")
}
/*
switchT1 == 1
*/

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")
}
/*
 The last letter of the alphabet
 */

• 与 C 和 Objective-C 中的switch语句不同，在 Swift 中，当匹配的 case 分支中的代码执行完毕后，程序会终止switch语句，而不会继续执行下一个 case 分支。这也就是说，不需要在 case 分支中显式地使用break语句。这使得switch语句更安全、更易用，也避免了因忘记写break语句而产生的错误

注意： 虽然在Swift中break不是必须的，但你依然可以在 case 分支中的代码执行完毕前使用break跳出

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

let anotherCharacter: Character = "a"
switch anotherCharacter {
case "a": // 无效，这个分支下面没有语句
case "A":
    print("The letter A")
default:
    print("Not the letter A")
}
// 这段代码会报编译错误

不像 C 语言里的switch语句，在 Swift 中，switch语句不会一起匹配"a"和"A"。相反的，上面的代码会引起编译期错误：case "a": 不包含任何可执行语句——这就避免了意外地从一个 case 分支贯穿到另外一个，使得代码更安全、也更直观
为了让单个case同时匹配a和A，可以将这个两个值组合成一个复合匹配，并且用逗号分开

let anotherCharacter: Character = "a"
switch anotherCharacter {
case "a", "A":
    print("The letter A")
default:
    print("Not the letter A")
}
// 输出 "The letter A

• 区间匹配
  case 分支的模式也可以是一个值的区间。下面的例子展示了如何使用区间匹配来输出任意数字对应的自然语言格式

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).")
// 输出 "There are dozens of moons orbiting Saturn."

• 元组
  我们可以使用元组在同一个switch语句中测试多个值。元组中的元素可以是值，也可以是区间。另外，使用下划线（_）来匹配所有可能的值。

下面的例子展示了如何使用一个(Int, Int)类型的元组来分类下图中的点(x, y)：

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")
}
// 输出 "(1, 1) is inside the box"

continue

continue语句告诉一个循环体立刻停止本次循环，开始下一次循环，就好像在说“本次循环我已经执行完了”，但是并不会离开整个循环体

break

break语句会立刻结束整个控制流的执行

• 循环语句中的 break
  当在一个循环体中使用break时，会立刻中断该循环体的执行，然后跳转到表示循环体结束的大括号(})后的第一行代码。不会再有本次循环的代码被执行，也不会再有下次的循环产生
• Switch 语句中的 break
  当在一个switch代码块中使用break时，会立即中断该switch代码块的执行，并且跳转到表示switch代码块结束的大括号(})后的第一行代码

fallthrough 贯穿

在 Swift 里，switch语句不会从上一个 case 分支跳转到下一个 case分支中。相反，只要第一个匹配到的 case 分支完成了它需要执行的语句，整个switch代码块完成了它的执行。相比之下，C 语言要求你显式地插入break语句到每个 case 分支的末尾来阻止自动落入到下一个 case 分支中。Swift的这种避免默认落入到下一个分支中的特性意味着它的switch 功能要比 C 语言的更加清晰和可预测，可以避免无意识地执行多个 case 分支从而引发的错误。

如果你确实需要 C 风格的贯穿的特性，你可以在每个需要该特性的 case 分支中使用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)
// 输出 "The number 5 is a prime number, and also an integer."

这个例子定义了一个String类型的变量description并且给它设置了一个初始值。函数使用switch逻辑来判断integerToDescribe变量的值。当integerToDescribe的值属于列表中的质数之一时，该函数在description后添加一段文字，来表明这个数字是一个质数。然后它使用fallthrough关键字来“贯穿”到default分支中。default分支在description的最后添加一段额外的文字，至此switch代码块执行完了。

如果integerToDescribe的值不属于列表中的任何质数，那么它不会匹配到第一个switch分支。而这里没有其他特别的分支情况，所以integerToDescribe匹配到default分支中。

当switch代码块执行完后，使用print(_:separator:terminator:)函数打印该数字的描述。在这个例子中，数字5被准确的识别为了一个质数

注意： fallthrough关键字不会检查它下一个将会落入执行的 case中的匹配条件。fallthrough简单地使代码继续连接到下一个 case 中的代码，这和 C 语言标准中的switch语句特性是一样的。

带标签的语句

在 Swift 中，你可以在循环体和条件语句中嵌套循环体和条件语句来创造复杂的控制流结构。并且，循环体和条件语句都可以使用break语句来提前结束整个代码块。因此，显式地指明break语句想要终止的是哪个循环体或者条件语句，会很有用。类似地，如果你有许多嵌套的循环体，显式指明continue语句想要影响哪一个循环体也会非常有用。

为了实现这个目的，你可以使用标签（statement label）来标记一个循环体或者条件语句，对于一个条件语句，你可以使用break加标签的方式，来结束这个被标记的语句。对于一个循环语句，你可以使用break或者continue加标签，来结束或者继续这条被标记语句的执行。

声明一个带标签的语句是通过在该语句的关键词的同一行前面放置一个标签，作为这个语句的前导关键字(introducor keyword)，并且该标签后面跟随一个冒号。下面是一个针对while循环体的标签语法，同样的规则适用于所有的循环体和条件语句

label name: while condition { statements }

提前退出

像if语句一样，guard的执行取决于一个表达式的布尔值。我们可以使用guard语句来要求条件必须为真时，以执行guard语句后的代码。不同于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(["name": "John"])
// 输出 "Hello John!"
// 输出 "I hope the weather is nice near you."
greet(["name": "Jane", "location": "Cupertino"])
// 输出 "Hello Jane!"
// 输出 "I hope the weather is nice in Cupertino."

如果guard语句的条件被满足，则继续执行guard语句大括号后的代码。将变量或者常量的可选绑定作为guard语句的条件，都可以保护guard语句后面的代码。

如果条件不被满足，在else分支上的代码就会被执行。这个分支必须转移控制以退出guard语句出现的代码段。它可以用控制转移语句如return,break,continue或者throw做这件事，或者调用一个不返回的方法或函数，例如fatalError()。

相比于可以实现同样功能的if语句，按需使用guard语句会提升我们代码的可读性。它可以使你的代码连贯的被执行而不需要将它包在else块中，它可以使你在紧邻条件判断的地方，处理违规的情况