/*控制转移语句：
continue: 本次循环完成了，开始下一次循环
break:结束循环，跳到循环体结束的大括号后的第一行代码
fallthrough:贯穿，会穿透当前，执行下一步
return
throw
*/
//=================================if、guard-else、for-in 语句=================================
let dataArr = [15,51,67,89,32]
var num = 0
for score in dataArr {//遍历数组，大于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)//输出的是判断结果
var optionName:String? = nil//"张三"
var greeting = "World！"
if let name = optionName{//optionName 不为nil,会把值赋值给name，这样在代码块中就可以用了
greeting = "Hello,\(name)"
}else{
greeting = "HelloKitty"//进入到此name相当于没有定义
}
//默认值 用 ?? 表示
let nickName:String? = "小四儿"// nil
let fullName:String? = "李四"
let informalGreeting = "Hi \(String(describing: nickName ?? fullName))"//如果nickName为nil就用fullName
//遍历数组和字典
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数组
if num > max {//如果value数组中的值大于max
max = num//就把这个值赋值给max
}
}
}
print("字典中的最大值为：\(max)")
//guard-else 提前退出：guard不成立则走else ,成立则走guard结束大括号后面的代码
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("字典中没有location这个值，此处也无此变量定义")
return
}
print("字典中既有name也有location:\(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循环结束后的n的值：\(n)")
var mm = 1
repeat {
mm = mm*2
}while mm<50
print("repeat-while循环中，结束条件后置：\(mm)")
var total = 0
for i in 0..<4 {
total += i
}
print("循环的范围：\(total)")//使用..< 创建的范围不包含上界，如果想包含的话需要使用...
var total2 = 0
for j in 0...4{
total2 += j
}
print("包括上界的循环范围：\(total2)")
//间隔遍历：每隔x遍历一次
for index in stride(from: 0, to: 60, by: 3) { //从0-60 每隔3 遍历一次
print("半开区间-间隔遍历：\(index)") // 0、3、6、9、……57 （to不包括60）
}
for index in stride(from: 1, through: 10, by: 2) {//遍历1-10，每隔2遍历一次
print("闭区间- 间隔遍历：\(index)")//1-10: 1、3、5、7、9； 0-10：0、2、4、6、8、10
}
/*蛇与梯子（见图snakesAndLadders_2x的示例：）
游戏规则：如果在梯子底部，会直接爬到梯子顶部；如果在蛇头，会直接滑到蛇尾；从0开始，每次掷骰子来决定走几步
*/
let geNum = 25;//表格的总数量
var geArr = [Int](repeating: 0, count: geNum+1);//初始化每个格子的规则 都为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 //记录当前所在的格子(从0开始)
var diceNum = 0 //记录每次掷骰子的数（模拟按每次+1：1、2、3、4、5、6、1）
while currentGe < geNum { //只要当前所在的格子小于25,游戏就没有结束
diceNum += 1//每次掷骰子数都在上次掷骰子的数的基础上+1
if diceNum == 7 { //如果超过了6，就回到1，继续
diceNum = 1
}
currentGe += diceNum //每次都往前移动掷出来的骰子数个格子
if currentGe < geArr.count {//如果游戏没有结束
currentGe += geArr[currentGe]// 额外再满足一下游戏的规则（上升或下滑）
print("当前格子数是：\(currentGe)")
}
}
print("游戏结束")
//=================================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”，就会走进这个匹配，并将tag的值赋值给常量x在代码块中使用
print("特色的switch-case语句：\(x)")//匹配上x的值就是tag的值
default:
print("没有符合的")
}
//case语句也可以是区间匹配，例如： case 1..<3: 这种
//switch匹配元组
let somePoint = (1,1)
switch somePoint {//如果条件满足很多个case，只会执行第一个满足的case，后面的都不会执行
case (0,0):
print("0，0")
case (_, 0):
print("在x轴上")
case (0,_):
print("在y轴上")
case (-2...2,-2...2):
print("在一个封闭的区间中")
default:
print("没找到")
}
//switch 允许判断条件为常量或者变量---值绑定
let anotherPoint = (2,0)
switch anotherPoint {
case (let x,0)://匹配一个y为0的点，并将这个点的横坐标传给x
print("匹配在x轴上的一个值：\(x)")
case (0,let y),(let y,0)://匹配一个x为0的点，并将这个点的纵坐标传给y;后面是一个复合匹配，let定义的变量需要一致才能在下面使用
print("匹配在y轴上的一个值：\(y)")
case let(x, y)://匹配任意一个x,y的点；由于肯定会满足这一条件，所以后面不需要再写默认的default分支了
print("匹配任意一个点的xy坐标：\(x,y)")
}
//switch 判断条件可以用where语句来增加额外的条件
let yetPoint = (1,-1)
switch yetPoint {
case let (x,y) where x == y://x,y都是占位符，需要满足where后面的条件才可以执行这个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)这个点不在上面那两条对角线上")
}
//=================================控制转移语句：=================================
//continue: 本次循环完成了，开始下一次循环
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:结束循环，跳到循环体结束的大括号后的第一行代码
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("匹配的结果为：\(posNum)")
}else{
print("没有匹配上")
}
//fallthrough:贯穿，会穿透当前，执行下一步
let desNum = 5
var desStr = "数据\(desNum)，"
switch desNum {
case 2,3,4,5,6:
desStr += "匹配上了"
fallthrough
case 0,1,7,8,9:
desStr += "，case穿透了"
default:
desStr += "，default穿透了"
}
print("穿透结果：\(desStr)")//带fallthrough语句，会直接穿透到下一步，而无视case的条件
//带标签的语句:为了在前提循环中很好的区分是哪个循环的break和continue,可以使用一个标签来标记一个循环体或者条件语句
//蛇与梯子的升级版：刚好落到最后一个格子才算胜利
let geNum2 = 25;//表格的总数量
var geArr2 = [Int](repeating: 0, count: geNum2+1);//初始化每个格子的规则 都为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 //记录当前所在的格子(从0开始)
var diceNum2 = 0 //记录每次掷骰子的数（模拟按每次+1：1、2、3、4、5、6、1）
gameLoop: while currentGe2 != geNum2 { //该循环的标签为gameLoop,只要当前格子不在终点格子上就循环
diceNum2 += 1//每次掷骰子数都在上次掷骰子的数的基础上+1
if diceNum2 == 7 { //如果超过了6，就回到1，继续
diceNum2 = 1
}
switch currentGe2 + diceNum2 {//当前格子数 + 骰子数
case geNum2://正好在终点格子上
break gameLoop //结束gameLoop的while循环（如果break后面没有带上while循环的标签gameLoop，那么他仅仅是中断了switch语句）
case let newSquare where newSquare > geNum2: //超过了终点格子--啥也不做，下一次循环
continue gameLoop //结束本轮gameLoop循环，开始下一次gameLoop循环
default://没有到终点、也没有超过终点
currentGe2 += diceNum2 //每次都往前移动掷出来的骰子数个格子
if currentGe2 < geArr2.count {//如果游戏没有结束
currentGe2 += geArr2[currentGe2]// 额外再满足一下游戏的规则（上升或下滑）
print("当前格子数是：\(currentGe2)")
}
}
}
print("带标签的游戏结束")
