天天看点
返回

Swift控制流For循环While循环条件分支控制转移提前退出检查API可用性其他

Swift提供了所有大家熟悉的控制流语法，其中包含多重循环的while和for循环；根据一定条件执行不同分支的if、guard和switch语法；以及控制流程转移的break和continue。

除此之外，Swift在for循环的基础上，增加了for-in循环。for-in循环可以快速帮你提取数组内的元素，同样支持字典、字符串以及其他集合。

swift的switch语法是非常强大的。它使得流程更加清晰化，让我想到了强大的AOP框架。在swith中的每个case，你不需要使用break返回，它是自动执行break操作的，不会执行下一个case内的代码。同时switch还支持其他强大的功能，如间隔匹配、元祖匹配、区域匹配、临时绑定常量匹配以及匹配时使用where做增加匹配。

For循环

Swift中的for循环提供了两种常用的模式，for-in和for

- for-in在遍历的过程中，能帮你快速提取元组中的对象；

- for和其他开发语言的for一样，中间三个条件，用“；”分割。

For-In 

// MARK: for-in循环
private func testForIn() {
    // 直接循环提取内部数据
    // [1,5]
    for index in . {
        print("\(index) times 5 is \(index * 5)")
    }
    // 不需要提取数据，只需要循环次数
    let base = 
    let power = 
    var answer = 
    for _ in ..power {
        answer *= base
    }
    print("\(base) to the power of \(power) is \(answer)")
    // array遍历
    let array = ["阳君", "937447974"]
    for item in array {
        print("array:\(item)!")
    }
    // Dictionary遍历
    let dict = ["name":"阳君", "qq":"937447974"]
    for (key, value) in dict {
        print("key:\(key);value:\(value)")
    }
}

For

For的一般结构如下所示：

Swift控制流For循环While循环条件分支控制转移提前退出检查API可用性其他

例子代码如下：

// MARK: - 传统for循环
private func testFor() {
    for var index = ; index < ; index++ {
        print("index is \(index)")
    }
}

While循环

While循环执行其内部的代码，直到条件为假。wihile提供了两种循环模式：

- while是先执行条件判断后执行内部代码；

- repeat-while是先执行内部代码后执行条件判断。

While

结构图：

Swift控制流For循环While循环条件分支控制转移提前退出检查API可用性其他
// MARK: - While循环
private func testWhile() {
    // 先执行while条件判断，后执行内部代码
    let count = 
    var index = 
    while index < count {
        index++
        print("while:\(index)")
    }
}

Repeat-While

结构图：

Swift控制流For循环While循环条件分支控制转移提前退出检查API可用性其他
// MARK: repeat-while循环
private func testRepeatWhile() {
    // 执行内部代码后判断条件
    let count = 
    var index = 
    repeat {
        index++
        print("RepeatWhile:\(index)")
    } while index < count
}

条件分支

条件分支主要用于在特定的条件执行不同的代码。当一个情况发生时，你可能想运行额外的代码，要做到这一点你就需要使用条件分支。

当你想在代码中使用条件分支时，Swift提供了两种语法if和switch。通常情况下你可以使用if来做普通的条件判断，当你的应用场景复杂化时可以是switch来代码分支。

If

if后跟的条件为真时，执行括号内的代码，否则跳过。

// MARK: if 判断
private func testIf() {
    // 一个条件一个条件的判断，当条件为真时，执行内部程序
    let temp = 
    if temp <=  {
        // 不执行
    } else if temp >=  {
        print("执行")
    } else {
        // 不执行
    }
}

Switch

Switch使用一个值去case匹配几种可能，当匹配成功时，执行其内部代码。结构图：

Swift控制流For循环While循环条件分支控制转移提前退出检查API可用性其他
// MARK: swich判断
private func testSwitch() {
    // 基本switch,case不会穿透。
    let someCharacter: Character = "a"
    switch someCharacter {
    case "a":
        print("1")
    case "a", "b", "c":
        print("2") //这里不会输出，case找到后，执行完毕就返回
    default:
        print("未找到")
    }
}

范围匹配

如同刻度尺，switch可以帮助你快速让一个点落到一个刻度尺范围内。它还可以帮你落到一个时间间隔内。

private func testSwitchIntervalMatching() {
    // 范围选择
    let approximateCount = 
    switch approximateCount {
    case .<:
        print("[1, 5)")
    case .<:
        print("[5, 10)")
    default:
        print("未找到")
    }
}

元组

在switch中你还可以使用元组匹配，如坐标点（1，1）。如果你只想匹配y，不关心x的值，你可以使用

(_)

，也就是匹配

（1，_）

。

// MARK: switch元组选择
private func testSwitchTuples() {
    // 元组选择,坐标轴测试
    let random = arc4random()// 随机数
    let somePoint = (Int(random%3), Int(random%3))// 随机数获取点
    switch somePoint {
    case (, ):
        print("(0, 0) is at the origin")
    case (_, ):
        print("(\(somePoint.0), 0) is on the x-axis")
    case (, _):
        print("(0, \(somePoint.1)) is on the y-axis")
    case (-., -.):
        print("(\(somePoint.0), \(somePoint.1)) is inside the box")
    default:
        print("(\(somePoint.0), \(somePoint.1)) is outside of the box")
    }
}

值绑定

当你使用元组匹配，而不关心匹配时的某个值，但你想拿到匹配成功的值，就可以使用值绑定，并用let声明的属性去获得这个值。

// MARK: switch值选择
private func testSwitchValueBindings() {
    let random = arc4random()// 随机数
    // 值绑定,如果设置未知数，当匹配成功时，执行此代码
    let anotherPoint = (Int(random%), Int(random%))
    switch anotherPoint {
    case (let x, ):
        print("\(x)，x匹配")
    case (, let y):
        print("\(y)，y匹配")
    case let (x, y):
        print("(\(x), \(y))，其他")
    }
}

值绑定和Where

在值绑定时，我们可以用where给未知数设置条件，当符合这个条件并且值绑定成功后才会执行内部语句。

// MARK: switch值绑定和where
private func testSwitchValueBindingsWhere() {
    // 使用where条件二次判断
    let random = arc4random()// 随机数
    let yetAnotherPoint = (Int(random%), Int(random%))
    switch yetAnotherPoint {
    case let (x, y) where x < y:
        print("\(x) < \(y)")
    case let (x, y) where x > y:
        print("\(x) > \(y)")
    case let (x, y):
        print("\(x) = \(y)")
    }
}

控制转移

控制转移可以帮助你改变代码执行的顺序。在swift中，控制转移有5种语法：

- continue

- break

- fallthrough

- return

- throw

Continue

跳过当前循环，并继续执行下一次循环。

// MARK: continue
private func testContinue() {
    // 跳过本次循环，继续执行下次循环
    for index in . {
        if index ==  {
            continue
        }
        print("continue:\(index)")
    }
}

Break

Break主要在for循环和switch中使用。在for循环中就是停止for循环，继续执行for循环体后的代码；在switch中，break以为着switch代码块执行结束，继续执行switch代码块后的代码。

// MARK: break
private func testBreak() {
    // 跳过当前for或者switch，继续执行
    for x in . {
        if x ==  {
            break
        }
        print("break-x:\(x)")
    }
    print("break-for")
    let z = 
    switch z {
    case :
        break;
    default:
        break;
    }
    print("break-switch")
}

Fallthrough

在swift中switch的case内的代码执行完毕后，默认执行break操作，这就意味着，你无法同时执行两个case内的代码。当你执行完毕一个case内的代码后，还想执行下一个case内的代码，就需要使用fallthrough（击穿）。

// MARK: fallthrough
private func testFallthrough() {
    // 击穿：执行当前case内的代码，并执行下一个case内的代码
    let x = Int(arc4random())// 0
    switch x {
    case:
        print("0")
        fallthrough
    case :
        print("1")
        fallthrough
    default:
        break;
    }
}

标签

在swift中，使用标签声明的代码块，在其内部你可以快速使用break停止这个标签体，或使用continue重新执行这个标签内的代码。

// MARK: 标签
private func testLabeledStatements() {
    // 标签语句，可以直接跳到写标签行的代码
    var b = false
    go : while true {
        print("go")
        switch b {
        case true:
            print("true")
            break go // 跳过go标签的代码
        case false:
            print("false")
            b = true
            continue go // 继续执行go标签的代码
        }
    }
}

提前退出

Guard语法和if很类似，在if中，当条件为true时执行其内部代码。guard和else合用，与if的差异性在于当条件为true跳过内部代码；条件为false时执行内部代码。

// MARK: - 提前退出
private func testEarlyExit() {
    // guard和if很像，当条件判断为假时，才执行else中的代码
    func greet(person: [String: String]) {
        guard let name = person["name"] else {
            print("无name")
            return
        }
        print("name: \(name)!")
    }

    greet([:])
    greet(["name": "阳君"])
}

检查API可用性

当你在swift中使用IOS9新增加的代码，而用户的手机使用的系统是IOS8时。程序运行到此处app会闪退，这是很不好的用户体验。swift根据这种情况，增加了用户版本判断工具#available()。

// MARK: - 检查API可用性
private func testCheckingAPIAvailability() {
    if #available(iOS 9.1, OSX 10.10, *) {
        print("iOS 9.1, OSX 10.10, *")
    } else {
        print("低版本")
    }
}

其他

参考资料

The Swift Programming Language (Swift 2.1)

文档修改记录

时间 描述
2015-10-26 根据 The Swift Programming Language (Swift 2.1)总结

版权所有：http://blog.csdn.net/y550918116j

swift 控制流
上一篇: Array数组
下一篇: swift _ 控制流

继续阅读