/*控制轉(zhuǎn)移語句：
 continue: 本次循環(huán)完成了，開始下一次循環(huán)
 break:結(jié)束循環(huán)，跳到循環(huán)體結(jié)束的大括號后的第一行代碼
 fallthrough:貫穿，會穿透當(dāng)前，執(zhí)行下一步
 return
 throw
 
 */
//=================================if、guard-else、for-in 語句=================================
let dataArr = [15,51,67,89,32]
var num = 0
for score in dataArr {//遍歷數(shù)組，大于50，num加3，否則加1
    if score > 50 {
        num += 3
    }else{
        num += 1
    }
}
print("num的值為：\(num)")

//可選值:在類型后加一個?
//可以使用if 和 let來處理值缺失的情況，這個值可以用可選值來代替（可選值是一個具體的值或者nil，如果是nil表示的是值缺失，在類型后面加一個?來表示這個變量的值是可選的）
var optionStr:String? = "Hello"
print(optionStr == nil)//輸出的是判斷結(jié)果

var optionName:String? = nil//"張三"
var greeting = "World！"
if let name = optionName{//optionName 不為nil,會把值賦值給name，這樣在代碼塊中就可以用了
    greeting = "Hello,\(name)"
}else{
    greeting = "HelloKitty"http://進(jìn)入到此name相當(dāng)于沒有定義
}

//默認(rèn)值 用 ?? 表示
let nickName:String? = "小四兒"http:// nil
let fullName:String? = "李四"
let informalGreeting = "Hi \(String(describing: nickName ?? fullName))"http://如果nickName為nil就用fullName

//遍歷數(shù)組和字典
let arrDic = ["x": [2, 3, 5, 7, 11, 13],
              "y": [1, 1, 2, 3, 5, 8],
              "z": [1, 4, 9, 16, 25],
             ]
var max = 0
for (_,value) in arrDic {//遍歷字典,前一個key用不到可以用_代替
    for num in value { //遍歷字典的每個value數(shù)組
        if num > max {//如果value數(shù)組中的值大于max
            max = num//就把這個值賦值給max
        }
    }
}
print("字典中的最大值為：\(max)")

//guard-else 提前退出：guard不成立則走else ,成立則走guard結(jié)束大括號后面的代碼
func testGuardGreet(person:[String: String]){
    guard let name = person["name"] else { //獲取字典中的name
        print("guard語句不成立，此處也沒有name這個變量")
        return
    }
    print("字典中有name:\(name)")
    guard let location = person["location"] else {
        print("字典中沒有l(wèi)ocation這個值，此處也無此變量定義")
        return
    }
    print("字典中既有name也有l(wèi)ocation:\(location)")
}
testGuardGreet(person: ["name":"張三"])
testGuardGreet(person: ["name" : "李四","location":"北京"])

//檢查API是否可用：
if #available(iOS 11, *){
    print("使用#available檢查 一些API是否可用")
}

//=================================while、repeat-While語句=================================
var n = 2
while n<100 {
    n = n*2
}
print("while循環(huán)結(jié)束后的n的值：\(n)")

var mm = 1
repeat {
    mm = mm*2
}while mm<50
print("repeat-while循環(huán)中，結(jié)束條件后置：\(mm)")

var total = 0
for i in 0..<4 {
    total += i
}
print("循環(huán)的范圍：\(total)")//使用..< 創(chuàng)建的范圍不包含上界，如果想包含的話需要使用...

var total2 = 0
for j in 0...4{
    total2 += j
}
print("包括上界的循環(huán)范圍：\(total2)")

//間隔遍歷：每隔x遍歷一次
for index in stride(from: 0, to: 60, by: 3) { //從0-60 每隔3 遍歷一次
    print("半開區(qū)間-間隔遍歷：\(index)") // 0、3、6、9、……57 （to不包括60）
}
for index in stride(from: 1, through: 10, by: 2) {//遍歷1-10，每隔2遍歷一次
    print("閉區(qū)間- 間隔遍歷：\(index)")//1-10: 1、3、5、7、9； 0-10：0、2、4、6、8、10
}

/*蛇與梯子（見圖snakesAndLadders_2x的示例：）
    游戲規(guī)則：如果在梯子底部，會直接爬到梯子頂部；如果在蛇頭，會直接滑到蛇尾；從0開始，每次擲骰子來決定走幾步
 */
let geNum = 25;//表格的總數(shù)量
var geArr = [Int](repeating: 0, count: geNum+1);//初始化每個格子的規(guī)則 都為0
geArr[3] = 8 //如果到了格子3，就加8，直接爬到格子11
geArr[6] = 11 //如果到了格子6，就加11，直接爬到格子17
geArr[9] = 9 //如果到了格子9，就加9，直接爬到格子18
geArr[10] = 2 //如果到了格子10，就加2，直接爬到格子12
geArr[14] = -10 //如果到了格子14，就減10，會直接滑到格子4
geArr[19] = -11 //如果到了格子19，就減11，直接滑到格子8
geArr[22] = -2 //如果到了格子22，就減2，直接滑到格子20
geArr[24] = -8 //如果到了格子24，就減8，直接滑到格子16

var currentGe = 0 //記錄當(dāng)前所在的格子(從0開始)
var diceNum = 0 //記錄每次擲骰子的數(shù)（模擬按每次+1：1、2、3、4、5、6、1）
while currentGe < geNum { //只要當(dāng)前所在的格子小于25,游戲就沒有結(jié)束
    diceNum += 1//每次擲骰子數(shù)都在上次擲骰子的數(shù)的基礎(chǔ)上+1
    if diceNum == 7 { //如果超過了6，就回到1，繼續(xù)
        diceNum = 1
    }
    currentGe += diceNum //每次都往前移動擲出來的骰子數(shù)個格子

    if currentGe < geArr.count {//如果游戲沒有結(jié)束
        currentGe += geArr[currentGe]// 額外再滿足一下游戲的規(guī)則（上升或下滑）
        print("當(dāng)前格子數(shù)是：\(currentGe)")
    }
}
print("游戲結(jié)束")

//=================================switch語句=================================
//switch語句：任意類型都可以，匹配上之后會退出switch，所以不需要再每個語句后面加上break;但是每個case分支后面都必須包含至少一條語句，否則會報錯，如果語句為空，就把這個case條件給去掉；或者直接寫break跳出switch
let tag = "red"
switch tag {
case "red":
    print("顏色為red")
    print("選對了")
case "green","GREEN": //一個case語句后面可以同時匹配多個，用逗號分隔
    print("顏色為--綠色")
case let x where x.hasSuffix("d")://如果前面都沒有匹配上，而且tag的后綴是“d”，就會走進(jìn)這個匹配，并將tag的值賦值給常量x在代碼塊中使用
    print("特色的switch-case語句：\(x)")//匹配上x的值就是tag的值
default:
    print("沒有符合的")
}
//case語句也可以是區(qū)間匹配，例如： case 1..<3: 這種
//switch匹配元組
let somePoint = (1,1)
switch somePoint {//如果條件滿足很多個case，只會執(zhí)行第一個滿足的case，后面的都不會執(zhí)行
case (0,0):
    print("0，0")
case (_, 0):
    print("在x軸上")
case (0,_):
    print("在y軸上")
case (-2...2,-2...2):
    print("在一個封閉的區(qū)間中")
default:
    print("沒找到")
}

//switch 允許判斷條件為常量或者變量---值綁定
let anotherPoint = (2,0)
switch anotherPoint {
case (let x,0)://匹配一個y為0的點(diǎn)，并將這個點(diǎn)的橫坐標(biāo)傳給x
    print("匹配在x軸上的一個值：\(x)")
case (0,let y),(let y,0)://匹配一個x為0的點(diǎn)，并將這個點(diǎn)的縱坐標(biāo)傳給y;后面是一個復(fù)合匹配，let定義的變量需要一致才能在下面使用
    print("匹配在y軸上的一個值：\(y)")
case let(x, y)://匹配任意一個x,y的點(diǎn)；由于肯定會滿足這一條件，所以后面不需要再寫默認(rèn)的default分支了
    print("匹配任意一個點(diǎn)的xy坐標(biāo)：\(x,y)")
}

//switch 判斷條件可以用where語句來增加額外的條件
let yetPoint = (1,-1)
switch yetPoint {
case let (x,y) where x == y://x,y都是占位符，需要滿足where后面的條件才可以執(zhí)行這個case
    print("\(x,y)在 x==y 這個對角線上")
case let (x,y) where x == -y:
    print("\(x,y)在 x==-y這個對角線上")
case let (x,y):
    print("\(x,y)這個點(diǎn)不在上面那兩條對角線上")
}

//=================================控制轉(zhuǎn)移語句：=================================
//continue: 本次循環(huán)完成了，開始下一次循環(huán)
let puzzleInput = "great minds think alike"
var puzzleOutput = ""
for character in puzzleInput {//遍歷字符串
    switch character {
    case "a","e","i","o","u"," "://跳過元音字符和空格
        continue
    default:
        puzzleOutput.append(character)//把其他的字符拼接到一塊
    }
}
print("拼接后的字符串為：\(puzzleOutput)")

//break:結(jié)束循環(huán)，跳到循環(huán)體結(jié)束的大括號后的第一行代碼
let numberSymbol:Character = "三"
var possibleIntValue: Int?
switch numberSymbol {
case "1","一","壹":
    possibleIntValue = 1
case "二","2","貳":
    possibleIntValue = 2
case "叁","3","三":
    possibleIntValue = 3
default:
    break
}
if let posNum = possibleIntValue {
    print("匹配的結(jié)果為：\(posNum)")
}else{
    print("沒有匹配上")
}

//fallthrough:貫穿，會穿透當(dāng)前，執(zhí)行下一步
let desNum = 5
var desStr = "數(shù)據(jù)\(desNum)，"
switch desNum {
case 2,3,4,5,6:
    desStr += "匹配上了"
    fallthrough
case 0,1,7,8,9:
    desStr += "，case穿透了"
default:
    desStr += "，default穿透了"
}
print("穿透結(jié)果：\(desStr)")//帶fallthrough語句，會直接穿透到下一步，而無視case的條件

//帶標(biāo)簽的語句:為了在前提循環(huán)中很好的區(qū)分是哪個循環(huán)的break和continue,可以使用一個標(biāo)簽來標(biāo)記一個循環(huán)體或者條件語句
//蛇與梯子的升級版：剛好落到最后一個格子才算勝利
let geNum2 = 25;//表格的總數(shù)量
var geArr2 = [Int](repeating: 0, count: geNum2+1);//初始化每個格子的規(guī)則 都為0
geArr2[3] = 8 //如果到了格子3，就加8，直接爬到格子11
geArr2[6] = 11 //如果到了格子6，就加11，直接爬到格子17
geArr2[9] = 9 //如果到了格子9，就加9，直接爬到格子18
geArr2[10] = 2 //如果到了格子10，就加2，直接爬到格子12
geArr2[14] = -10 //如果到了格子14，就減10，會直接滑到格子4
geArr2[19] = -11 //如果到了格子19，就減11，直接滑到格子8
geArr2[22] = -2 //如果到了格子22，就減2，直接滑到格子20
geArr2[24] = -8 //如果到了格子24，就減8，直接滑到格子16

var currentGe2 = 0 //記錄當(dāng)前所在的格子(從0開始)
var diceNum2 = 0 //記錄每次擲骰子的數(shù)（模擬按每次+1：1、2、3、4、5、6、1）
gameLoop: while currentGe2 != geNum2 { //該循環(huán)的標(biāo)簽為gameLoop,只要當(dāng)前格子不在終點(diǎn)格子上就循環(huán)
    diceNum2 += 1//每次擲骰子數(shù)都在上次擲骰子的數(shù)的基礎(chǔ)上+1
    if diceNum2 == 7 { //如果超過了6，就回到1，繼續(xù)
        diceNum2 = 1
    }
    switch currentGe2 + diceNum2 {//當(dāng)前格子數(shù) + 骰子數(shù)
    case geNum2://正好在終點(diǎn)格子上
        break gameLoop //結(jié)束gameLoop的while循環(huán)（如果break后面沒有帶上while循環(huán)的標(biāo)簽gameLoop，那么他僅僅是中斷了switch語句）
    case let newSquare where newSquare > geNum2: //超過了終點(diǎn)格子--啥也不做，下一次循環(huán)
        continue gameLoop //結(jié)束本輪gameLoop循環(huán)，開始下一次gameLoop循環(huán)
    default://沒有到終點(diǎn)、也沒有超過終點(diǎn)
        currentGe2 += diceNum2 //每次都往前移動擲出來的骰子數(shù)個格子
        if currentGe2 < geArr2.count {//如果游戲沒有結(jié)束
            currentGe2 += geArr2[currentGe2]// 額外再滿足一下游戲的規(guī)則（上升或下滑）
            print("當(dāng)前格子數(shù)是：\(currentGe2)")
        }
    }
}
print("帶標(biāo)簽的游戲結(jié)束")