流程控制是我们程序员中必不可少的，各种判断什么的都需要，我们的程序，基本每一个模块度需要流程控制

if else判断语句

swift的if-else和OC的稍微有点区别的，和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循环语句

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的区别：
repeat ... while最少会执行一次，while的条件表达式是在循环结束时执行；
正常的while是在一开始就检查条件表达式。

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

for-in 循环语句

我们先初始化一个数组,我们接下来for-in循环的数据都来自这个数组

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

正常的遍历循环

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

for循环闭区间运算符

其中闭区间书写方法a...b，含义是a<= 取值 <=b

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

当然这里的闭区间也可以单独声明，或者是传值,例如

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

使用闭区间运算符，但是我们循环过程中不使用i值,可以将i的部分写成_,swift里面_是的简写语法，我理解的含义是忽略这个值，但我通常不推荐这么写

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

for循环半开区间运算符

其中半开区间书写方法a..<b，含义是 a<= 取值 < b
使用方法如下

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

使用半开区间运算符实现OC语言中for循环的样式

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

无论是闭区间运算符还是半开区间运算符，条件那里都都可以声明称常量(let)

那么怎么实现在OC中for in的效果呢？
还是以上边的names数组为例
使用闭区间

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

不使用闭区间，实现OC样式，其实就是省略了声明

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

for循环单侧区间

单侧区间会让循环的条件朝一个方向尽可能的远
例如开始为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

同样单侧区间运算也可以加条件

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

区间类型

刚才写到了单侧区间,该区间的类型是PartialRangeThrough

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

区间的类型

//闭区间，下面的含义是 <=1 && >=3
let range1: ClosedRange<Int> = 1...3
//半开区间,下面的含义是 <=1 && <3
let range2: Range<Int> = 1..<3
//单侧区间,下面的含义是 <=10
let range3: PartialRangeThrough<Int> = ...10

当然字符和字符串也能使用区间运算符，但是默认这样的区间运算符不能使用在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"..."~"`

带间隔的区间值

比如，在一个循环中，从3开始，每次累加2，所有结果<15,一般用在for循环里面

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，不会产生贯穿到下面的情况
4.如果要实现贯穿效果，那么在当前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区间匹配

使用区间进行匹配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循环里面，
例如计算所有正整数的和，使用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

标签语句

就是给循环起一个名字，这样我们就可以在内部嵌套的那个循环控制外边这个循环;
下述这个就是的逻辑是，当K==3时跳过当前outer的循环，当i==3时跳出outer的循环,也就都跳出去了

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