/*For-In 循环
While 循环
• 条件语句
• 控制转移语句(Control Transfer Statements)
• 提前退出 (
• 检测 API 可用性 */

    //使用 for-in 循环来遍历一个 合中的所有元素
    for index in 1...5 {
        print("\(index) times 5 is \(index * 5)")
    }
    //如果你不需要区间序列内每一项的值,你可以使用下划线( _ )替代变量名来忽略这个值:
    let base = 3
    let power = 10
    var answer = 1
    for _ in 1...power {
        answer *= base
    }
    print("\(base) to the power of \(power) is \(answer)")
    
    
    //使用 for-in 遍历一个数组所有元素:
    let names = ["Anna", "Alex", "Brian", "Jack"]
    for name in names {
        print("Hello, (name)!")
    }
    
    
    //while 循环
    //while 循环会一直运行一段语句直到条件变成 false 。这类循环适合使用在第一次迭代前,迭代次数未知的情况下
    //while循环,每次在循环开始时计算条件是否符合;
    //repeat-while循环,每次在循环结束时计算条件是否符合。
    
    
    /*游戏的规则如下:
    • 游戏盘面包括 25 个方格,游戏目标是达到或者超过第 25 个方格;
    • 每一轮,你通过掷一个六面体骰子来确定你移动方块的步数,移动的路线由上图中横向的虚线所示; 
    • 如果在某轮结束,你移动到了梯子的底部,可以顺着梯子爬上去;
    • 如果在某轮结束,你移动到了蛇的头部,你会顺着蛇的身体滑下去。*/
    let finalSquare = 25
    var board = [Int](repeating: 0, count: finalSquare + 1)
    
    board[03] = +08; board[06] = +11; board[09] = +09; board[10] = +02
    board[14] = -10; board[19] = -11; board[22] = -02; board[24] = -08

    var square = 0
    var diceRoll = 0
    while square < finalSquare {
        // 掷骰子
        diceRoll += 1
        if diceRoll == 7 { diceRoll = 1 } // 根据点数移动
        square += diceRoll
        if square < board.count {
            // 如果玩家还在棋盘上,顺着梯子爬上去或者顺着蛇滑下去
            square += board[square]
        }
    }
    print("Game over!")

    //Repeat-While
    //while 循环的另外一种形式是 repeat-while ,它和 while 的区别是在判断循环条件之前,先执行一次循环的代码 块。然后重复循环直到条件为 false 。
    
    //条件语句 If
    
    var temperatureInFahrenheit = 30
    if temperatureInFahrenheit <= 32 {
        print("It's very cold. Consider wearing a scarf.")
    }
    // 输出 "It's very cold. Consider wearing a scarf."
    
    temperatureInFahrenheit = 40
    if temperatureInFahrenheit <= 32 {
        print("It's very cold. Consider wearing a scarf.")
    } else {
        print("It's not that cold. Wear a t-shirt.")
    }
    // 输出 "It's not that cold. Wear a t-shirt."
    
    temperatureInFahrenheit = 90
    if temperatureInFahrenheit <= 32 {
        print("It's very cold. Consider wearing a scarf.")
    } else if temperatureInFahrenheit >= 86 {
        print("It's really warm. Don't forget to wear sunscreen.")
    } else {
        print("It's not that cold. Wear a t-shirt.")
    }
    // 输出 "It's really warm. Don't forget to wear sunscreen."
    
    
    //switch
    
    //switch 语句会尝试把某个值与若干个模式(pattern)进行匹配。根据第一个匹配成功的模式, switch 语句会执 行对应的代码。当有可能的情况较多时,通常用 switch 语句替换 if 语句。
    //switch 语句最简单的形式就是把某个值与一个或若干个相同类型的值作比较:
    
    let someCharacter: Character = "z"
    switch someCharacter {
    case "a":
        print("The first letter of the alphabet")
    case "z":
        print("The last letter of the alphabet")
    default:
        print("Some other character")
    }
    // 输出 "The last letter of the alphabet"
    
    //为了让单个case同时匹配 a 和 A ,可以将这个两个值组合成一个复合匹配,并且用逗号分开:
    let anotherCharacter: Character = "a"
    switch anotherCharacter {
    case "a", "A":
        print("The letter A")
    default:
        print("Not the letter A")
    }
    // 输出 "The letter A
    
    
    //区间匹配
    //case 分支的模式也可以是一个值的区间。下面的例子展示了如何使用区间匹配来输出任意数字对应的自然语言格 式:
    
    let approximateCount = 62
    let countedThings = "moons orbiting Saturn"
    var naturalCount: String
    switch approximateCount {
    case 0:
        naturalCount = "no"
    case 1..<5:
        naturalCount = "a few"
    case 5..<12:
        naturalCount = "several"
    case 12..<100:
        naturalCount = "dozens of"
    case 100..<1000:
        naturalCount = "hundreds of"
    default:
        naturalCount = "many"
    }
    print("There are \(naturalCount) \(countedThings).")
    
    
    //元组
    //我们可以使用元组在同一个 switch 语句中测试多个值。元组中的元素可以是值,也可以是区间。另外,使用下划 线( _ )来匹配所有可能的值。
    //下面的例子展示了如何使用一个 (Int, Int) 类型的元组来分类下图中的点(x, y):
    let somePoint = (1, 1)
    switch somePoint {
    case (0, 0):
        print("(0, 0) is at the origin")
    case (_, 0):
        print("(\(somePoint.0), 0) is on the x-axis")
    case (0, _):
        print("(0, \(somePoint.1)) is on the y-axis")
    case (-2...2, -2...2):
        print("(\(somePoint.0), \(somePoint.1)) is inside the box")
    default:
        print("(\(somePoint.0), \(somePoint.1)) is outside of the box")
    }
    // 输出 "(1, 1) is inside the box"

    //值绑定(Value Bindings)
    //case 分支允许将匹配的值绑定到一个临时的常量或变量,并且在case分支体内使用 —— 这种行为被称为值绑 定(value binding),因为匹配的值在case分支体内,与临时的常量或变量绑定。
    //下面的例子展示了如何在一个 (Int, Int) 类型的元组中使用值绑定来分类下图中的点(x, y):
    let anotherPoint = (2, 0)
    switch anotherPoint {
    case (0, let y):
        print("on the x-axis with an x value of \(y)")
    case (2, let y):
        print("on the y-axis with a y value of \(y)")
    case let (x, y):
        print("somewhere else at (\(x), \(y))")
    }
    // 输出 "on the x-axis with an x value of 2"
    
    //Where
    //case 分支的模式可以使用 where 语句来判断额外的条件。
    //下面的例子把下图中的点(x, y)进行了分类:
    
    let yetAnotherPoint = (1, -1)
    switch yetAnotherPoint {
    case let (x, y) where x == y:
        print("(\(x), \(y)) is on the line x == y")
    case let (x, y) where x == -y:
        print("(\(x), \(y)) is on the line x == -y")
    case let (x, y):
        print("(\(x), \(y)) is just some arbitrary point")
    }
    // 输出 "(1, -1) is on the line x == -y"
    
   // 复合匹配
    //当多个条件可以使用同一种方法来处理时,可以将这几种可能放在同一个 case 后面,并且用逗号隔开。当case后 面的任意一种模式匹配的时候,这条分支就会被匹配。并且,如果匹配列表过长,还可以分行书写:
    
    let somesCharacter: Character = "e"
    switch somesCharacter {
    case "a", "e", "i", "o", "u":
        print("\(somesCharacter) is a vowel")
    case "b", "c", "d", "f", "g", "h", "j", "k", "l", "m",
         "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z":
        print("\(somesCharacter) is a consonant")
    default:
        print("\(somesCharacter) is not a vowel or a consonant")
    }
    // 输出 "e is a vowel"

    

    //控制转移语句
    /*
     • continue
     • break
     • fallthrough 
     • return
     • throw
     */
    
    //continue
    //continue 语句告诉一个循环体立刻停止本次循环,重新开始下次循环。就好像在说“本次循环我已经执行完 了”,但是并不会离开整个循环体。
    let puzzleInput = "great minds think alike"
    var puzzleOutput = ""
    for character in puzzleInput.characters {
        switch character {
        case "a", "e", "i", "o", "u", " ":
            continue
        default:
            puzzleOutput.append(character)
        }
    }
    print(puzzleOutput)
    // 输出 "grtmndsthnklk"
    
    //break:break 语句会立刻结束整个控制流的执行。当你想要更早的结束一个 switch 代码块或者一个循环体时,你都可以 使用 break 语句。
    let numberSymbol: Character = "三" // 简体中文里的数字 3 
    var possibleIntegerValue: Int?
    switch numberSymbol {
    case "1", "?", "一", "?":
        possibleIntegerValue = 1
    case "2", "?", "二", "?":
        possibleIntegerValue = 2
    case "3", "?", "三", "?":
        possibleIntegerValue = 3
    case "4", "?", "四", "?":
        possibleIntegerValue = 4
    default:
        break
    }
    if let integerValue = possibleIntegerValue {
        print("The integer value of \(numberSymbol) is \(integerValue).")
    } else {
        print("An integer value could not be found for \(numberSymbol).")
    }
    // 输出 "The integer value of 三 is 3."
    
    
    //贯穿 fallthrough
    let integerToDescribe = 5
    var description = "The number \(integerToDescribe) is"
    switch integerToDescribe {
    case 2, 3, 5, 7, 11, 13, 17, 19:
        description += " a prime number, and also"
        fallthrough
    default:
        description += " an integer."
    }
    print(description)
    // 输出 "The number 5 is a prime number, and also an integer."
    
    //提前退出 return
    
    //像 if 语句一样, guard 的执行取决于一个表达式的布尔值。我们可以使用 guard 语句来要求条件必须为真 时,以执行 guard 语句后的代码。不同于 if 语句,一个 guard 语句总是有一个 else 从句,如果条件不为真则执 行 else 从句中的代码。
    
    func greet(person: [String: String]) {
        
        guard let name = person["name"] else {
            return
        }
        print("Hello \(name)")
        
        guard let location = person["location"] else {
            
            print("I hope the weather is nice near you.")
            return
        }
        
        print("I hope the weather is nice in \(location).")
    }
    greet(person: ["name": "John"])
    // 输出 "Hello John!"
    // 输出 "I hope the weather is nice near you." greet(["name": "Jane", "location": "Cupertino"]) // 输出 "Hello Jane!"
    // 输出 "I hope the weather is nice in Cupertino."
    
    
    //检测API可用性
    //我们在 if 或 guard 语句中使用 可用性条件(availability condition) 去有条件的执行一段代码,来在运行时判 断调用的API是否可用。编译器使用从可用性条件语句中获取的信息去验证,在这个代码块中调用的 API 是否可 用。
    
    if #available(iOS 10, macOS 10.12, *) {
        // 在 iOS 使用 iOS 10 的 API, 在 macOS 使用 macOS 10.12 的 API
    } else {
        // 使用先前版本的 iOS 和 macOS 的 API
    }