系列文章目录
第一章：量值与基本数据类型
第二章：字符、字符串与集合类型
文章目录
- 系列文章目录
- 空合并运算符
- 区间运算符
- 循环结构
- while与repeat-while条件循环结构
空合并运算符
可选值类型是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("第几次循环")
}
}
