流程控制是我們程序員中必不可少的，各種判斷什么的都需要，我們的程序，基本每一個模塊度需要流程控制

if else判斷語句

swift的if-else和OC的稍微有點區(qū)別的，和OC不一樣的是，if 后邊的條件表達式不用寫(),但是后面的大括號不能省略
例如：

var age : Int = 4;
if age >= 22 {
    print("get married")
} else if age >= 18 {
    print("being a adult")
} else if age >= 7 {
    print("go to school")
} else {
    print("just a child")
}

where循環(huán)語句

var num = 5
while num > 0 {
    print("num is \(num)")
    num -= 1
}

//打印結果分別是5、4、3、2、1

除了while 還有 repeat ... while，repeat {} while類似于C語言的 do ... while,

while 和 repeat ... while的區(qū)別：
repeat ... while最少會執(zhí)行一次，while的條件表達式是在循環(huán)結束時執(zhí)行；
正常的while是在一開始就檢查條件表達式。

var num2 = -1
repeat {
    print("num is \(num2)")
} while num2 > 0

for-in 循環(huán)語句

我們先初始化一個數(shù)組,我們接下來for-in循環(huán)的數(shù)據(jù)都來自這個數(shù)組

let names = ["xiaoMing", "xiaoHong", "xiaoWang", "xiaoZhang"]

正常的遍歷循環(huán)

for name in names {
    print("name is \(name)")
}
//打印結果：
//xiaoMing
//xiaoHong
//xiaoWang
//xiaoZhang

for循環(huán)閉區(qū)間運算符

其中閉區(qū)間書寫方法a...b，含義是a<= 取值 <=b

for i in 0...3 {
    print("name is \(names[i])")
}
//打印結果
//xiaoMing
//xiaoHong
//xiaoWang
//xiaoZhang

當然這里的閉區(qū)間也可以單獨聲明，或者是傳值,例如

let range = 1...3
for i in range {
    print("name is \(names[i])")
}
//打印結果
//xiaoHong
//xiaoWang
//xiaoZhang

使用閉區(qū)間運算符，但是我們循環(huán)過程中不使用i值,可以將i的部分寫成_,swift里面_是的簡寫語法，我理解的含義是忽略這個值，但我通常不推薦這么寫

for _ in 1...3 {
    print("今天又是美好的一天")//將會打印三次`今天又是美好的一天`
}

for循環(huán)半開區(qū)間運算符

其中半開區(qū)間書寫方法a..<b，含義是 a<= 取值 < b
使用方法如下

for i in 0..<3 {
    print("name is \(names[i])")
}
//打印結果
//xiaoMing
//xiaoHong
//xiaoWang

使用半開區(qū)間運算符實現(xiàn)OC語言中for循環(huán)的樣式

for i in 0..<names.count {
    print("name is \(names[i])")
}

無論是閉區(qū)間運算符還是半開區(qū)間運算符，條件那里都都可以聲明稱常量(let)

那么怎么實現(xiàn)在OC中for in的效果呢？
還是以上邊的names數(shù)組為例
使用閉區(qū)間

for name in names[0...3] {
    print("name is \(name)")
}

不使用閉區(qū)間，實現(xiàn)OC樣式，其實就是省略了聲明

for name in names {
    print("name is \(name)")
}

for循環(huán)單側區(qū)間

單側區(qū)間會讓循環(huán)的條件朝一個方向盡可能的遠
例如開始為1，一直取到names最后一個值，

for name in names[1...] {
    print("name is \(name)")
}
//打印結果如下
//name is xiaoHong
//name is xiaoWang
//name is xiaoZhang

例如開始為names最小值，一直取到2位置的值

for name in names[...2] {
    print("name is \(name)")
}
//取值位置為`0.1.2`,打印結果如下
//name is xiaoMing
//name is xiaoHong
//name is xiaoWang

同樣單側區(qū)間運算也可以加條件

for name in names[..<2] {
    print("name is \(name)")
}

區(qū)間類型

剛才寫到了單側區(qū)間,該區(qū)間的類型是PartialRangeThrough

let range = ...100//含義是無限小至100
print(range.contains(50))   //true
print(range.contains(103))  //false
print(range.contains(-1000))//true

區(qū)間的類型

//閉區(qū)間，下面的含義是 <=1 && >=3
let range1: ClosedRange<Int> = 1...3
//半開區(qū)間,下面的含義是 <=1 && <3
let range2: Range<Int> = 1..<3
//單側區(qū)間,下面的含義是 <=10
let range3: PartialRangeThrough<Int> = ...10

當然字符和字符串也能使用區(qū)間運算符，但是默認這樣的區(qū)間運算符不能使用在for-in中
以字符串舉個例子

//字符串
let stringRange = "a"..."g"
print(stringRange.contains("d"))//true
print(stringRange.contains("m"))//false

//字符，如果用字符需要單獨聲明
let characterRange = "\0"..."~"
print(characterRange.contains("G"))//true
print(characterRange.contains("9"))//true
`let characterRange = "\0"..."~"等同于let characterRange:ClosedRange<Character> = "\0"..."~"`

帶間隔的區(qū)間值

比如，在一個循環(huán)中，從3開始，每次累加2，所有結果<15,一般用在for循環(huán)里面

let number = 15
let numberInterval = 2
for num in stride(from: 3, to: number, by: numberInterval) {
    print(num)
}
//打印結果
//3
//5
//7
//9
//11
//13

switch

和OC的大同小異，幾個注意的點
1.case和default后面不能有大括號{}，
2.每個case和default后面最少要有一條語句，如果沒有自己要寫的語句，可以寫break
3.case和default后面如果有代碼語句，則可以省略break，不會產(chǎn)生貫穿到下面的情況
4.如果要實現(xiàn)貫穿效果，那么在當前case結束時添加fallthrough關鍵字
5.switch的case需要保證能處理所有的情況，有兩種選擇方法，
第一個是在不想處理的地方加break，第二個是寫上default
下面舉個例子：

var number = 3
switch number {
case 3:
    print("number is 3")
    fallthrough
case 4:
    print("number is 4")
    break
case 5:
    print("number is 5")
    break
default:
    print("number is other")
    break
}
//打印結果:
//number is 3
//number is 4

當然也可以在case后面跟上多復合條件，以下面這個例子就是，當number為5、6、7都會進入case 5,6,7比如：

let number = 5
switch number {
case 5,6,7:
    print("number 5,6,7")
case 8:
    print("number 8")
default:
    print("number is other")
}
//打印結果
//number 5,6,7

switch區(qū)間匹配

使用區(qū)間進行匹配case

let number = 55
switch number {
case 0:
    print("number = 0")
case 1..<10:
    print("1<= number < 10")
case 10...30:
    print("10<= number <= 30")
case 31..<80:
    print("31 <= number < 80")
case 80...100:
    print("80 <= number <= 100")
default:
    print("number is other")
}
//打印結果
///31 <= number < 80

switch元組匹配

let point = (1, 1)
switch point {
case (0, 0):
    print("point (0, 0)")
case (_, 0):
    print("point (_, 0)")
case (0, _):
    print("point (0, _)")
case (-2...2, -2...2):
    print("ponit inside the box")
default:
    print("point other")
}
//打印結果：
//ponit inside the box

值綁定

只要有一個值符合case，那么case上另一個值默認被條件值綁定

let point = (3, 5)
switch point {
case (let x, 4):
    print("x point \(x)")
case (4, var y):
    print("y point \(y)")
case let (x, y):
    print("point \(x),\(y)")
}
//打印結果:
//point 3,5

值綁定外加條件語句where

let point = (1, 1)
switch point {
case let (x, y) where x == y:
    print("x == y")
case let (x, y) where x > y:
    print("x > y")
case let (x, y) where x < y:
    print("x < y")
case (_, _):
    print(point)
}
//打印結果
//x == y

當然條件語句不一定必須在switch里面，比如可以加在for循環(huán)里面，
例如計算所有正整數(shù)的和，使用where語句可以省下一個if

let numbers = [28, -22, -56, 0 ,78, 25, 99, -1]
var sum : Int = 0
for number in numbers where number > 0 {
    sum += number
}
//print("sum is \(sum)")
//打印結果
//sum is 230

標簽語句

就是給循環(huán)起一個名字，這樣我們就可以在內(nèi)部嵌套的那個循環(huán)控制外邊這個循環(huán);
下述這個就是的邏輯是，當K==3時跳過當前outer的循環(huán)，當i==3時跳出outer的循環(huán),也就都跳出去了

outer: for i in 1...4 {
    for k in 1...4 {
        if k == 3 {
            continue outer
        }
        if i == 3 {
            break outer
        }
        print("i == \(i), k == \(k)")
    }
}

輸出的結果應該沒有3也沒有4