2-1 流程控制

1. if-else 可以省略条件()，声明{}不能省略
2. if-else 条件必须是 Bool 类型，即 true false
   补充：SwiftGG if 文档
3. while 有两种执行方式：
   1. while 循环开始就判断条件是否满足

   while condition {
       statement
   }
   

   3. repeat-while 循环执行完再判断条件是否满足

   repeat {
       statement
   } while condition
   

4. 区间运算符
   1. 闭区间运算符：ClosedRange<T>，a...b，表示 a<= value <=b
   2. 半闭区间运算符：Range<T>，a..<b，表示 a<= value <b
   3. 单边区间运算符，只有下限或者上限
      1. PartialRangeUpTo<T>，...b，表示 ∞ value <=5
      2. PartialRangeUpFrom<T>，a...，表示 a<= value ∞
   4. 字符、字符串也能使用区间运算符

   // 需要标注类型，否则默认为 String 类型的区间
   let character: ClosedRange<Character> = "\0"..."~" // ClosedRange<Character> 类型
   let str = "a"..."d" // ClosedRange<String> 类型
   

   5. 区间是否包含某个值，使用 contains

   let result = character.contains("a") // true
   

5. for-in 使用
   1. 遍历字典是无序的，无法确定取值顺序
   2. 无需取值，用 _ 代替取值，默认定义的取值是 let，也可手动定义为 var

   for _ in 0...4 {
     // ...
   }
   
   for i in 0...4 {
     // 系统默认 i 是常量，用let接收
   }
   
   for var i in 0...4 {
     // 可以自定义 i 为变量，用var接收
     // i = i + 1，定义为了变量，可修改
   }
   

   3. 利用区间运算符，遍历数组部分元素

   let names = ["小明", "小花", "小红"]
   for var name in names[0...1] {
     print("名字：\(name)")
   }
   // 名字：小明
   // 名字：小花
   // name 定义为变量，声明中可以改变
   

   4. 不能遍历字符、字符串的区间运算符
   5. 有一定间隔的遍历：

   let start = 0
   let end = 15
   let interval = 4 // 间隔为4
   for i in stride(from: start, to: end, by: interval) {
     print("间隔遍历：\(i)")
   }
   for i in stride(from: start, through: end, by: interval) {    
     print("间隔遍历：\(i)")
   }
   

   6. 可以遍历任何集合，包括实现了 Sequence 的自定义类或者集合类型
6. Switch
   1. 不需要显示的使用 break，因为不会隐式的贯穿，执行完一条 case，就会跳出
   2. 每条 case 分支都必须包含至少一条语句
   3. 同条 case 分支匹配多个值，符合匹配，可以用 , 分开
   4. case 后的申明不需要用 {}
   5. 需要贯穿执行下条 case，使用 fallthrough 关键字
   6. 可以使用区间运算符、元组进行匹配

   let point = (3,9)
   switch point {
   case (0,0):
     print("坐标在原点")
   case (_,0), (0,_): // 多个符合匹配，用逗号隔开
     print("坐标在坐标轴上")
   case (-10...10, -10...10): // 使用区间运算符进行匹配
     print("坐标在区域内")
     fallthrough // 强制贯穿，继续执行下一个case
   default:
     print("坐标在区域外")
   }
   

   7. 值绑定，能将 case 的匹配值，临时声明为 let var，并在当前 case 的实现中调用

   switch point {
     case (let x, 0): // 匹配 y = 0，则将 x 赋值给 x
       print("x轴上，距离：\(x)")
     case (0, var y): // 匹配 x = 0，则将 y 赋值给 y
       print("y轴上，距离：\(y)")
     case (let x, let y): // 匹配 x != 0 && y != 0，并将 point 值赋值给 x y
       print("x: \(x), y: \(y)")
   }
   

   8. case 中可以添加 where 做临时过滤器，只有 where 条件为 true，才会走该 case 分支

   switch point {
     case let (x, y) where y == 0: // 匹配 y == 0，则将 x 赋值给 x，此时 y == 0
       print("x轴上，x: \(x)，y: \(y)")
     case let (x, y) where x == 0: // 匹配 x == 0，则将 y 赋值给 y，此时 x == 0
       print("y轴上，x: \(x)，y: \(y)")
     case let (x, y):
       print("x: \(x)，y: \(y)") // 匹配 x != 0 && y != 0，并将 point 值赋值给 x y
   }
   

   9. 同一个 case 匹配的多个值（称为复合匹配），也能进行值绑定，但是每个匹配值必须有相同的常量/变量，且类型一致，以便在执行该 case 时，使用常量/变量能对应上

   switch point {
     // 复合匹配，定义的 value，需要每个匹配值都有
     // 确保不管匹配上哪种情况，print 都能取到 value 值
     case (let value, 0), (0, let value): 
       print("在坐标轴上：\(value)")
     case let (x, y):
       print("x: \(x)，y: \(y)")
   }
   

7. 多层嵌套控制流，可以使用 标签语句，指定某个控制流执行 continue break 等

 // label name 是标签名，自定义
 label name: while condition {
     statements
 }

let list = [1, 2, 3, 4, 5]

// 自定义外层 for 的标签是 outer
outer: for i in list {
  for j in list {
    if (j == i && j == 3) {
      break outer // 跳出外层循环
    }
  }
}