Swift小知识点之流程控制

• if-else

  • if后面的条件可以省略小括号, 条件后面的大括号不可以省略

    例如下面是可以的

    let score = 70
    if score >= 80 {
        print("优秀")
    }else if score >= 60{
        print("及格")
    }else{
        print("不及格")
    }

  • if后面的条件只能是bool类型
    

    例如下面是不可以的

    if score {
        print("aa")
    }

• while

  • repeat-while 相当于C语言中的 do-while
  • 下面代码中没有用num--，是因为从Swift3开始，去掉了自增(++)、自减(--)运算符

  var num = 5
  while num > 0 {
      print("num is \(num)")
      num -= 1
  }// 会打印五次
  
  var num = 5
  repeat {
      print("num is \(num)")
       num -= 1
  }while num > 0// 会打印五次

• for

  • 闭区间运算符: a...b，代表着: a <= 取值 <= b

    let persons = ["zhangsan","lisi","wanger","mazi"]
    for i in 0...3 {
        print(persons[i])
    }
    //结果为
    //zhangsan
    //lisi
    //wanger
    //mazi

    我们也可以用range来表示区间，例如

    let persons = ["zhangsan","lisi","wanger","mazi"]
    let range = 0...3
    for i in range {
        print(persons[i])
    }
    //结果为
    //zhangsan
    //lisi
    //wanger
    //mazi

    我们也可以用变量来表示区间，例如

    let persons = ["zhangsan","lisi","wanger","mazi"]
    let before = 0
    var end = 3
    for i in before...end {
        print(persons[i])
    }
    //结果为
    //zhangsan
    //lisi
    //wanger
    //mazi

    我们也可以用变量和数值共同使用来表示区间，例如

    let persons = ["zhangsan","lisi","wanger","mazi"]
    let before = 0
    for i in before...3 {
        print(persons[i])
    }
    //结果为
    //zhangsan
    //lisi
    //wanger
    //mazi

  • 半开区间运算符：a..<b 表示 a <= 取值 < b

    let persons = ["zhangsan","lisi","wanger","mazi"]
    for i in 1..<3 {
        print(persons[i])
    }
    //结果为
    //lisi
    //wanger

  • 带间隔的区间值
    
    使用 stride(from:to:by:) 函数来跳过不想要的标记 (开区间)。
    使用 stride(from:through:by:) 函数来跳过不想要的标记 (闭区间)。 

    let all = 100
    let interval = 20
    // res的取值为从 10 开始 每次间隔 20，直到100结束，
    for res in stride(from: 10, to: all, by: interval) {
        print(res)
    }

    // 结果为
    //10
    //30
    //50
    //70
    //90

  • 区间运算符用在数组上 例如

    • 双侧区间

      let nums = [1,2,3,4]
      for num in nums[0...3] {
          print(num)
      }
      //结果为
      //1
      //2
      //3
      //4

• • • 单侧区间
      

      let nums = [1,2,3,4]
      for num in nums[0...] {
          print(num)
      }
      //结果为
      //1
      //2
      //3
      //4

      或者

      let nums = [1,2,3,4]
      for num in nums[..<4] {
          print(num)
      }
      //结果为
      //1
      //2
      //3
      //4

• 区间类型

  • 如下三种

    • let range1: ClosedRange = 1...3
    • let range2: Range = 1..<3
    • let range3: PartialRangeThrough = ...5

    字符、字符串也可以使用区间运算符，但默认不能使用在for-in中 例如

    这样写是可以的

    let strRange = "a"..."f"
    strRange.contains("d") // true
    strRange.contains("l") // false

    但是下面是会报错的

    for i in strRange {
        print(i)
    }

  • \0 到 "~" 包括了所有的要用到的ASCII字符 例如我们要判断一个字符是否是ASCII字符
    

    let characterRange: ClosedRange<Character> = "\0"..."~"
    //想判断s是否是ASCII字符可以
    characterRange.contains("s") //返回true 

• switch

  • case、default 后面不能写大括号{}
  • 默认可以不写break，并不会贯穿到后面的条件
    

    var res = 1
    switch res {
    case 0:
        print("res = 0")
    case 1:
        print("res = 1")
    case 2:
        print("res = 2")
    default:
         print("other res")
    }
    // 输出为 res = 1

  • 关键字 fallthrough

    如果我们想让其贯穿下去，就是用 fallthrough 这个关键字 例如

    var res = 1
    switch res {
    case 0:
        print("res = 0")
    case 1:
        print("res = 1")
        fallthrough
    case 2:
        print("res = 2")
    default:
         print("other res")
    }
    // 输出为
    // res = 1
    // res = 2

  • switch中支持 字符串，字符类型
    1、字符串

    let string = "aaa" 
    switch string { 
    　　case "aaa": 
    　　　　print("string is aaa") 
    　　case "bbb": 
    　　　　print("string is bbb") 
    　　default: break 
    } 
    // string is aaa

    2、字符类型

    let character: Character = "a" 
    switch character { 
    　　case "a","A": 
    　　　　print("string is a or A") 
    　　default: 
    　　　　print("string is not a or A") 
    } 
    //string is a or A

  • 区间、元组匹配
    1、可以用下划线_ 忽略某个值

    let point = (1,1)
    switch point {
    case (0,0):
        print("这个点在坐标原点")
    case (_,0):
        print("这个点在x轴上")
    case (0,_):
        print("这个点在y轴上")
    case (-2...2,-2...2):
        print("这个点在矩形框内")
    default:
        print("这个点在其他位置上")
    }

    2、可以对区间，和元组进行匹配

    • 区间

      let count = 8
      switch count {
      　　case 0:
          　　print("0")
      　　case 1..<5:
          　　print("1到4")
      　　case 5..<10:
          　　print("5到10")
      　　default:
          　　break
      }
      //5到10

    • 元祖
      

      let point = (1,0)
      switch point {
      case (0, 0):
          print("原点")
      case (_, 0):
          print("x轴")
      case (0, _):
          print("y轴")
      case (-2...2, -2...2):
          print("区间")
      
      default:
           print("other")
      }
      /

  • 值绑定

    let point2 = (1,0)
    switch point2 {
    case (0, 0):
        print("原点")
    case (let x, 0):
        print("x轴 x是 \(x)")
    case (0, let y):
        print("y轴 y是 \(y)")
    case let (x, y):
        print("somewhere else at (\(x),\(y))")
        
    default:
        print("other")
    }
    // x轴 x是 1

 

• where
  

  where在 Swift 中使用来过滤事物，在 Swift 的各个地方，where子句提供了一个约束，并明确指示您要使用的数据或类型。where 可用于 switch - case 语句、do - catch 语句以及 if、while、guard、for-in 的条件以及定义类型约束。而我们需要注意在 Swift 3.0 之后某些地方可以用,代表where。

  • 在 if 语句里面使用（这里用,代表了where）

    if let path = webUrl, path.hasPrefix("https") {    
       //...
    }

  • 在 guard 中使用（这里用,代表了where）

    guard let path = webUrl , path.hasPrefix("https") else {
       //...
    }

  • 在 for 循环中使用
    在使用for循环遍历arrays、ranges等,如果想过滤要循环中的一些条件可以使用for in``where

    下面求偶数的例子：

    var numArray: [Int] = [0,1,2,3,4,5,6,7,8,9]
    for val in numArray where (val % 2 == 0) {
       print(val)
    }

  • 在 while 中使用

    var numArray:[Int]? = []
    while let arr = numArray, arr.count < 5 {
       numArray?.append(arr.count)
    }

  • 在 switch-case 中使用

    enum Response {
        case error(Int, String)
        case success
    }
    func test() {
        let httpResponse = Response.success
        switch httpResponse {
        case .error(let code, let status) where code == 401:
            print("HTTP Error: \(code) \(status)")
        case .error:
            print("HTTP Request failed")
        case .success:
            print("HTTP Request was successful")
        }
    }

    在上面的代码中，我们定义了网络请求返回的简单情况，即.error和.success。用来返回的值，Response我们只是想检查网络请求响应是否正常。
    为此，我们使用.error和.success。而我们可以将细分一些错误情况如当401的时候我们就知道接口未授权。可能是未登录，或者登录失效。

• • 在 do-catch 中使用
    

    您可以使用do-catch语句通过运行代码块来处理错误。如果do子句中的代码抛出错误，则将其与catch子句进行匹配以确定其中哪一个可以处理错误。
    这是do-catch语句的一般形式：

    do {
        try expression
        statements
    } catch pattern 1 {
        statements
    } catch pattern 2 where condition {
        statements
    } catch pattern 3, pattern 4 where condition {
        statements
    } catch {
         statements
    }

    在下面例子写一个模式catch来指示该子句可以处理哪些错误。这里需要注意顺序很重要。

    do {
       try update(name: "Antoine van der Lee", forUserIdentifier: "AEDKM1323")
    } catch User.ValidationError.emptyName {
       // Called only when the `User.ValidationError.emptyName` error is thrown
    } catch User.ValidationError.nameToShort(let nameLength) where nameLength == 1 {
       // Only when the `nameToShort` error is thrown for an input of 1 character
    } catch is User.ValidationError {
       // All `User.ValidationError` types except for the earlier catch `emptyName` error.
    } catch {
       // All other errors
    }

在 类型约束 中使用，类型约束是指定类型参数必须从特定的类继承，或者符合特定的协议或协议组合。例如，Swift 的Dictionary类型限制了可以用作字典键的类型。

• • 在 方法 中使用
    

    func doSomething<T>(_ string: T) where T: ExpressibleByStringLiteral {
       print(string)
    }

    上面的对于当传入的元素符合ExpressibleByStringLiteral协议,可以进行方法的实现。

  • 在 扩展 中使用
    

    extension Array where Element : Numeric {
       ...
    }

    上面的对于数组的扩展是当元素符合Numeric协议 可以进行下面{}里面功能。

    extension Array where Element == String {
       ....
    }

    上面的对于数组的扩展是当元素是String类型 可以进行下面{}里面的功能。
    上面的代码使用了Element ,它是一种通用占位符，可以称作是数组实际类型的“替代品”，这是一个属于泛型的概念，

  • 高阶函数 中的使用
    

    removeAll(where:) 移除所有符合的元素 true
    contains(where:) 返回的所有符合的元素 true
    first(where:) 返回的第一个符合的元素 true
    firstIndex(where:)返回的第一个符合的索引 true
    last(where:)、lastIndex(where:) 这同样适用于它返回最后一个元素、索引

    案例：
    

    var numArray: [Int] = [0,1,2,3,4,5,6,7,8,9]
    numArray.first (where: { $0 % 2 == 0 } )
    numArray.firstIndex(where: {$0 % 2 == 0} )

• 标签语句

  • 标签语句用于执行的时候，跳转到标签的位置

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

    输出为

    i == 1, k == 1
    i == 1, k == 3
    i == 1, k == 4
    i == 2, k == 1
    i == 2, k == 3
    i == 2, k == 4

  • 如果加了标签

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

    输出为

    i == 1, k == 1
    i == 2, k == 1