SwiftNote-4
2016年04月27日 Swift

for语句

Swift对for语句进行了增强，不但有C语言里那种普通形式的三段式的for循环，还增加了for in这种区间式for循环

  • 常规for循环，同其他语言三段式的for循环，形式相同，只不过Swift省略了中间的括号

    1
    2
    3
    4
    for var i = 0; i < 10; i += 2
    {
        print("output same 5 times")
    }

  • for .. in形式的循环，可以遍历数组，字典，集合，也可以遍历一个区间，有点类型于lua的for in 语法形式

    1. 区间内循环

      1
      2
      3
      4
      for index in 1 ..< 10
      {
        	print("index = \(i)")
      }

      这里的index不需要let或者var声明，每次迭代都对对index自动赋值，一直到区间结束。

    2. 集合的遍历

      1
      2
      3
      4
      5
      let dictionary:[Int:String] = [1:"Swift", 2:"bugcode", 3:"Github"]
      for (key, val) in dictionary // 以元组的形式拿出数据
      {
          print("key = \(key) value = \(val)")
      }

    3. 遍历字符串，与遍历集合类似

      1
      2
      3
      4
      5
      var string:String = "Swift Demo"
      for char in string.characters
      {
          print("single character = \(char)")
      }

while 语句

与C形式相同，只是去掉了括号，类似的还有repeat .. while，与C语言的do .. while形式相同，也是至少执行一次

  • While

    1
    2
    3
    4
    5
    6
    7
    var count = 0
    var summary = 0
    while count < 10
    {
        summary += count
        count += 1
    }

  • repeat .. while

    1
    2
    3
    4
    repeat
    {
      	print("execute 1 time at less")
    }while false

条件语句

  • if语句

    与C语言形式相同，也只是省去了括号

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    let flag = 1
    if flag == 1  // 这里必须是一个bool值
    {
      	print("flag == 1")
    }
    else if flag == -1
    {
      	print("flag == -1")
    }
    else
    {
      	print("flag == \(flag)")
    }

  • switch 语句

    Swift对switch语句进行了非常大的增加，不仅仅可以对相同与否作比较，还支持各种类型的各种形式的比较与操作。包括where子句，区间对比，元组匹配等

    1. 常规switch，Swift的switch的case也不像C语言那样需要手动加break，不加break就会一直贯穿下去，如下：

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      int x = 10;
      switch (x)
      {
        case 1: // 这里即是隐式的贯穿
        case 2:
        case 3:
          printf("x == 1 or x == 2 or x == 3");
      	break; 	// 必须手动加break，不然会一直贯穿到下一个case
        case 4:
        default:
          printf("default");
      }

      Swift不存在隐式的贯穿，且必须有default分支，不然会有语法错误，每个case和default下必须有可执行的语句，否则也会报语法错误，如果想要case贯穿下去，则需要显式指定，使用fallthough关键字，可以在case后有n个备选值，这样来达到某些情况的贯穿需求

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      var switchTest = 1
      switch switchTest
      {
      case 1:
          print("1")
          fallthrough // 显式的贯穿，case 2也会执行
      case 2:
          print("2")
      case 3:
          print("3")
      case 4:
          print("4")
      case 5, 6, 7: // 多个匹配值，都会匹配到这个case
          print("5 or 6 or 7")
      default:
          print("default case")  // default必须存在
      }

    2. 区间匹配的switch

      1
      2
      3
      4
      5
      6
      7
      8
      9
      switch switchTest
      {
      case 1 ... 4:
          print("1 <= \(switchTest) <= 4")
      case 5 ..< 10:
          print("5 <= \(switchTest) < 10") //  进入这个case
      default:
          print("defualt")
      }

    3. 元组匹配，Apple开发者官网上的例子非常好，直接移过来，可以匹配具体的某一个元组，也可以匹配二个区间的元组，如果元组内某个值要匹配任意值，就使用_(下划线)来表示任意值

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      var point = (1, 1)
      switch point
      {
      case (1, 2): // 匹配某个具体点
          print("point (1, 2)")
      case (-2 ... 2, -2 ... 2): // 匹配一个区间
          print("in range -2 -> 2")
      case (_, 1): // 只匹配第二个值
          print("just matching y")
      case (_, _): // 匹配任意， 因为此处已能处理所有情况，所以这个switch可以没有default
          print("match any point")
      }

    4. case中的值绑定和where子句，可以在case语句中对匹配的值进行赋值给一个临时变量/常量，然后可以在case语句中直接引用这个变量/常量，where子句相当于是针对值绑定的做了一个更深入的条件匹配，这里就能体现出switch不仅仅只能做一般的普通比较，可以自定义各种条件来匹配case

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      point = (2, 5)
      switch point
      {
      case (1, let y): // 第二个值绑定到y上，这个case里就可以使用y
          print("point (1, 2)")
      case (let x, 1) where x % 2 == 0: // x绑定到了第一个值上，且使用where子句过滤掉x不是2的倍数的值，相当是case的加强条件
          print("just matching y")
      case (let x, let y) where x + y == 7: // 二个值分别绑定在了x和y上，匹配x + y == 7的元组
          print("x + y == 7")
      default:
          print("default handler")
      }

循环条件转移语句

  • break

    常规用法与C语言相同，中断一个循环或者switch语句，跳到循环体或者switch大括号的下一句代码继续执行。通常用在switch的情况就是想忽略某个分支而不想写无用的语句，case语句里就可以直接写break，比如default里不想处理时，就可以直接default中写break语句直接忽略掉default。

    带标签的break，可以为某个循环或者switch指定标签，而break后带一个标签，显式指定要中断哪个循环或者switch

    labeName: for i in range

    break labelName // 显式指定要中断的循环体，直接跳出对应的标签的循环体去下一行执行

  • continue

    常用用法也是与C语言相同，直接跳过本次循环，继续下一次循环。

    continue也有与break相同的带标签的用法，意思就是直接开始标签所标示的的循环的下一次循环

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    outerLabel:for i in 1 ... 5
    {
        print("outter loop \(1)")
        for j in 5 ... 10
        {
            print("inner loop \(j)")
            if j == 6
            {
                continue outerLabel //  内部循环不再往后进行，直接开始下次外层循环
            }
        }
    }

    ​