Swift--基本运算符与程序流程控制

系列文章目录

第一章：量值与基本数据类型
第二章：字符、字符串与集合类型

---

---

空合并运算符

可选值类型是Swift语言的一个独特之处，空合并运算符就是针对可选值类型而设计的运算符

var q:Int? = 8
var value:Int
if q != nil {
    value = q!
} else {
    value = 0
}

var q:Int? = 8
var value:Int
value = (q != nil) ? (q!) : 0

Swift语言中还提供了空合并运算符来更加简洁地处理这种Optional类型值的条件选择结构，空合并运算符由“??”表示

空合并运算符“??”是一个二元运算符，使用空合并运算符改写后的代码更加简洁。其需要两个操作数，第一个操作数必须为一个Optional值，如果此Optional值不为nil，则将其进行拆包操作，并作为空合并运算的运算结果。如果此Optional值为nil，则会将第二个操作数作为空合并操作运算的结果返回。使用空合并操作符来处理有关Optional值的选择逻辑将十分方便

区间运算符

//表示大于0小于10的范围
index > 0 && index < 10
//创建范围>= 0 且<= 10的闭区间
var range1 = 0...10
//创建范围>= 0且<10的半开区间
var range2 = 0..<10


//判断8是否在range1中
print(range1 ~= 8)

区间运算符常见于for-in循环结构中

//a...b为闭区间写法
for index in 0...3 {
    print(index)
}
//a..<b为左闭右开区间
for index in 0..<3 {
    print(index)
}

循环结构

for index in 1...5 {
    print(index)
}

for-in结构中需要两个参数，第2个参数可以是一个集合类型的实例，也可以是一个范围区间，第1个参数为捕获参数，每次从第2个参数中遍历出的元素便会赋值给它，开发者在循环结构中可以直接使用

var collection1:Array = [1, 2, 3, 4]
var collection2:Dictionary = [1:1, 2:2, 3:3, 4:4]
var collection3:Set = [1, 2, 3, 4]
for obj in collection1 {
    print(obj)
}
for (key, value) in collection2 {
    print(key, value)
}
for obj in collection3 {
    print(obj)
}

while与repeat-while条件循环结构

只是Swift语言将do-while结构修改为repeat-while

var i = 0
//当i不小于10的时候跳出循环
while i < 10 {
    print("while", i)
    //进行i的自增
    i = i + 1
}

var j = 0
//先执行一次循环体， 在判断循环条件是否成立
repeat {
    print("repat while")
    j = j + 1
} while j < 10

var c = 10
//进行if判断
if c < 10 {
    print(c)
}
//进行if-else组合
if c > 10 {
    c = c - 10
    print(c)
} else {
    print(c)
}
//进行if-else多分支组合
if c > 0 && c < 10 {
    print(c)
} else if c <= 10 {
    c = -c
    print(c)
} else if c <= 10 && c < 20 {
    c = c - 10
    print(c)
} else {
    print("bigger")
}

var charac = "a"
switch charac {
case "a":
    print("chara is a")
case "b":
    print("chara is b")
case "c":
    print("chara is c")
default:
    print("no chara")
}

在C/Objective-C语言中，case语句不会因匹配成功而中断，如果不进行手动控制，switch结构中的case子句会依次进行匹配执行
switch-case结构也支持开发者在一个case子句中编写多个匹配条件，程序在执行到这个case子句时，只要有一个条件匹配成功，就会执行此case下的代码

var charac = "a"
switch charac {
case "a", "b", "c":
    print("chara is word")
case "1", "2", "3":
    print("chara is num")
default:
    print("no chara")
}

case子句的匹配条件也可以是一个区间范围，当要匹配的参数在这个区间范围内时，就会执行此case下的代码

var num = 3
switch num {
case 1...3:
    print("1 <= num <= 3")
    
case 4:
    print("chara is num")
default:
    print("no charac")
    
}

在进行元组的匹配时，有3种方式可以选择：第1种方式是完全匹配，即元组中所有元素都必须完全相等，才算匹配成功；第2种方式是选择匹配，即开发者只需要指定元组中的一些元素进行匹配，不需要关心的元素可以使用匿名参数标识符来代替，这种方式下，只要指定的参数都相等，就算匹配成功；第三种方式是范围匹配，即相应位置指定的范围包含需匹配元组相应位置的值，就算匹配成功。其中第2种匹配方式可以和第3种匹配方式组合使用。

var tuple = (0, 0)
switch tuple {
case(0, 1):
    print("sure")
case (_, 1):
    print("Sim")
case (0...3, 0...3):
    print("SIM")
default:
    print("")
}

var tuple = (0, 0)
//进行数据绑定
switch tuple {
case (let a, 1):
    print(a)
case (let b, 0):
    print(b)
case let(a, b):
    print(a, b)
default:
    print("")
}

//对于进行了数据捕获的Switch-case结构， 可以使用where关键字来进行条件判断
switch tuple {
case (let a, 1):
    print(a)
case (let b, 0) where b == 0:
    print(b)
case let(a, b) where a == b:
    print(a, b)
default:
    print("")
}

//对于进行了数据捕获的Switch-case的结构，可以使用where关键字来进行条件判断
switch tuple {
case (let a, 1):
    print(a)
case (let b, 0) where b == 0:
    print(b)
//当元祖中的两个元素相同时，才会进入下面的case
case let(a, b) where a == b:
    print(a, b)
default:
    print("")
}

for index in 0...9 {
    if index == 6 {
        continue
    }
    print("第几次循环")
}

上面的示例代码将跳过index等于6时的代码块，在打印信息中会缺少index等于6时的打印输出

MyLabel:for indexI in 0...2 {
    for indexJ in 0...2 {
        if indexI == 1 {
            continue MyLabel
        }
        print("第几次循环")
    }
}