枚举
枚举基本用法
//写法一
enum Direction {
case east,west,south,north
}
//写法二
enum NewDirection {
case east
case west
case south
case north
}
//当变量已确定为枚举类型，再次赋值可省略
var dir = Direction.west
dir = .north
print(dir)
不同于C/OC,枚举成员不会分配默认的整数值
当变量已确定为枚举类型，再次赋值可省略
枚举关联值
枚举的成员值和其他类型的值关联存储在一起 会非常有用（在后续窥探内存就会明白其中的含义为什么叫关联存储）
enum Password {
case numbers(Int, Int, Int, Int)
case gesture(String)
}
var pwd = Password.numbers(3, 5, 7, 8)
pwd = .gesture("1235")
switch pwd {
case let .numbers(n1, n2, n3, n4)://必要时let也可以改成var
print(n1, n2, n3, n4)
case .gesture(let string):
print(string)
}
枚举原始值
- 枚举成员可以使用相同类型的默认值 该默认值为原始值
- 原始值不占用枚举变量的内存
- 原始值
//Charater为原始值类型 代表枚举成员关联的原始值为Charater
enum PokerType :Character {
case spade = "♠"
case heart = "♥"
case diamond = "♦"
case club = "♣"
}
var suit = PokerType.spade
print(suit,suit.rawValue,PokerType.spade.rawValue)//输出：spade ♠ ♠
- 隐式原始值
如果枚举的原始值类型是Int/String 则会自动分配原始值
//隐式原始值为Int类型
//如果只设置部分成员原始值 未设置的依照前面的值递增
enum NewDirection:Int {
case east
case west = 3
case south
case north
}
print(NewDirection.east)//输出：east
print(NewDirection.east.rawValue)//输出：0
print(NewDirection.south.rawValue)//输出：4
//隐式原始值为String类型
enum Direction:String {
case east
case west
case south
case north
}
print(Direction.east)//输出：east
print(Direction.east.rawValue)//输出：east
如果隐式原始值为Int类型,只设置部分成员原始值 未设置的依照前面的值递增
递归枚举
- indirect 在使用自身枚举之前一定要先添加 indirect
//写法一
indirect enum Recursive {
case number(Int)
case sum(Recursive,Recursive)
case difference(Recursive,Recursive)
}
//写法二
enum Recursive {
case number(Int)
indirect case sum(Recursive,Recursive)
indirect case difference(Recursive,Recursive)
}
let first = Recursive.number(5)
let second = Recursive.number(6)
let third = Recursive.number(7)
let forth = Recursive.sum(first, second)
let fifth = Recursive.difference(forth, third)
let sixth = Recursive.difference(forth, fifth)
func caculate(_ expr:Recursive) -> Int {
switch expr {
case let .number(value):
return value
case let .sum(left, right):
return caculate(left) + caculate(right)
case let .difference(left, right):
return caculate(left) - caculate(right)
}
}
print(caculate(sixth))//输出：7
MemoryLayout
- 使用MemoryLayout获取数据类型占用的内存大小
enum Password {
case number(Int, Int, Int, Int)
case other
}
var pwd = Password.number(5, 6, 7, 8)
pwd = .other
//枚举类型
MemoryLayout<Password>.stride//系统分配的空间 40（33 内存对齐之后 则为40）
MemoryLayout<Password>.size//实际能用到的空间 32 + 1
MemoryLayout<Password>.alignment//内存对齐 8
//枚举变量
MemoryLayout.stride(ofValue: pwd)
MemoryLayout.size(ofValue: pwd)
MemoryLayout.alignment(ofValue: pwd)
【注意】
- 枚举原始值
enum OneDefault:String{
case one
}
MemoryLayout<OneDefault>.stride//1
MemoryLayout<OneDefault>.size//0
MemoryLayout<OneDefault>.alignment//1
enum TwoDefault:String{
case one, two
}
MemoryLayout<TwoDefault>.stride//1
MemoryLayout<TwoDefault>.size//1
MemoryLayout<TwoDefault>.alignment//1
原因：只有一个的时候，不给它分配内存 1个以上才会分配
- 枚举关联值
enum Associate{
// case one(String,String)
case two(String)
// case three(Int)
case four
}
//16+0
print(MemoryLayout<Associate>.stride) //16
print(MemoryLayout<Associate>.size)//16
print(MemoryLayout<Associate>.alignment)//8
enum NewAssociate{
case one(String,String)
// case two(String)
case three(Int)
case four
}
//32+1
print(MemoryLayout<NewAssociate>.stride) //40
print(MemoryLayout<NewAssociate>.size)//33
print(MemoryLayout<NewAssociate>.alignment)//1
为什么是16+0呢？不懂
窥探枚举成员的内存布局
- 有多个case的情况下：
- N个字节存储关联值（N取占用内存最大的关联值） 任何一个case都共用这N个字节
- 1个字节存储成员值
- 只有一个case的情况
- 枚举原始值不分配字节0 关联值为case关联值占用字节
PS： MJ-窥探内存小工具
如何窥探内存？
- 获取地址
enum Associate{
case one(String,String)
case two(String)
case three(Int)
case four
}
var value = Associate.two("abc")
print(Mems.ptr(ofVal: &value))//输出：0x00000001000076f0
value = .four
-
View Memory of "value"
View Memory of "value"
- 通过MemoryLayout打印为33字节 输入地址 即得证明实际使用33字节 （分配为40字节）
image.png
可选项 (可选类型)
什么是可选类型
- 在可能缺少值的情况下使用可选类型。
- 可选项表示两种可能性：要么存在值，打开可选项以访问该值，要么根本没有值
- 可选类型，允许将值设置为nil
- 类型后面加(?)来定义一个可选项
//可以对可选类型设置nil
var code:String? = "Hello,playground"
code = nil //设置为nil
//不提供默认值定义可选变量，会自动设置为nil
var value :String?//默认为nil
可选类型的概念在C或OC中不存在
Swift中nil 和 OC中的nil OC中的nil指向不存在对象的指针 Swift中nil代表缺少某种类型的值 不只是用于对象类型
//该例中：返回值可能为空，可选类型作为返回值
var dataArray = [10,20,30,40]
func getIndexValue(_ index:Int) -> Int?{
if index < 0 || index > dataArray.count {
return nil
}
return dataArray[index]
}
print(getIndexValue(5),
getIndexValue(-1)
,getIndexValue(3))//输出：nil nil Optional(40)
强制解包 为什么要强制解包？
- 可选项是其实对其他类型的一种包装
- 为nil，盒子为空；不为nil 盒子内是被包装的数据
- 如果要从可选项中取出被包装的数据，则需要使用(!)强制解包
var age :Int? = 10
var ageInt : Int = age!
ageInt += 10
print(age,ageInt)//输出：Optional(10) 20
【注意】
强制解包仅仅是取出数据使用，并不影响原可选变量的值
如果对值为nil的可选项进行强制解包，将会产生运行错误
可选项绑定
- 使用可选项绑定来确定可选项是否包含值
- 如果是，则使该值可用作临时常量或变量。 可选绑定常与if和while语句一起使用，以检查可选内部的值，并将该值提取为常量或变量，作为单个操作的一部分
//举例1 条件语句
var num = Int("123")//num为Int?
if let num = Int("123"){
print(num)//不用再加！
}
//举例2 枚举
enum Season:Int {
case spring = 4,summer,autumn,winter
}
if let season = Season.init(rawValue: 3) {
switch season {
case .spring:
print("spring")
default:
print("Other")
}
}
else{
print("并不包含在枚举类型之内")//输出
}
//while循环中使用可选项绑定
var stringArr = ["20", "-20", "25", "-10", "60", "100"]
var index = 0
var sum = 0
while let num = Int(stringArr[index]), abs(num) > 10 {
sum += num
index += 1
}//遇到条件不符合的 停止遍历
print(sum)
空合运算符
- a （可选项） b（可选项或不是可选项）
- a 和 b的存储类型要相同
- a 不为 nil 返回 a 反之 返回b（返回类型取决于b）
- b不是可选项 返回a会自动解包
空合运算符
多个情况下c的结果
【注意】多个??一起使用会怎么样？
类型取决于最右边
guard语句
guard语句
- 当guard语句为false,会执行大括号内的语句
- 当guard语句为true，会跳过guard语句
- guard适合用于“提前退出”
- 当使用guard进行可选绑定时，绑定的常量/变量可在外层作用域访问（见下例）
【具体事例见第五章 控制流】
隐式解包
- 在首次设置该值之后，可选项将始终具有值，之后访问时就不需要检查和解包可选项的值
- 被定义为隐式解包的选项，可以通过在要使其成为可选类型之后放置感叹号（String！）来编写隐式解包的可选项。
- 隐式可选就是在任意的已有类型后面添加“！”。Int？和Int！的区别就是：当程序获取Int？类型的值时，程序必须在变量名后添加“！”后缀来进行强制解析，而Int！则不需要，Swift会自动的执行隐式解析
//可选类型
let num1 :Int? = 10
let num2 = num1!//需要加!
//隐式可选类型
let num1 :Int! = 10
let num2 = num1//不需要加!
//let num1 :Int = 10
如果能确定num1的值为什么不直接用Int类型的变量呢？因为上者可设置nil 下者不可以
多重可选类型
var num1 :Int? = 10
var num2 :Int?? = num1
var num3 :Int?? = 10
print(num2 == num3)//输出：true
var num4 :Int? = nil
var num5 :Int?? = num4
var num6 :Int?? = nil
print(num5 == num6)//输出：false
print((num5 ?? 1) ?? 2)//2
print((num6 ?? 1) ?? 2)//1
为何结果会不相同呢？
通过使用lldb指令frame variable -R 或者fr v -R +(变量名) 可以查看区别
num2与num3
num5与num6
image
image
可选类型在字符串插值 或直接print时会报警告
解决办法：
- 强制解包
- String(describing:)函数 （只是不报警告，print依然是Optional(value)类型）
- value??0
Swift学习日记7.0
