七、枚举类型 可选项

枚举

枚举基本用法

//写法一
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)
}

枚举原始值

• 枚举成员可以使用相同类型的默认值 该默认值为原始值
• 原始值不占用枚举变量的内存

1. 原始值

//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 ♠ ♠

2. 隐式原始值
   如果枚举的原始值类型是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)

【注意】

1. 枚举原始值

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个以上才会分配

2. 枚举关联值

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呢？不懂

窥探枚举成员的内存布局

1. 有多个case的情况下：

• N个字节存储关联值（N取占用内存最大的关联值） 任何一个case都共用这N个字节
• 1个字节存储成员值

2. 只有一个case的情况

• 枚举原始值不分配字节0 关联值为case关联值占用字节
  PS： MJ-窥探内存小工具

如何窥探内存？

1. 获取地址

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

2. View Memory of "value"

   
   View Memory of "value"

3. 通过MemoryLayout打印为33字节 输入地址 即得证明实际使用33字节 （分配为40字节）

image.png

可选项 (可选类型)

什么是可选类型

1. 在可能缺少值的情况下使用可选类型。
2. 可选项表示两种可能性：要么存在值，打开可选项以访问该值，要么根本没有值
3. 可选类型，允许将值设置为nil
4. 类型后面加(?)来定义一个可选项

//可以对可选类型设置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)

强制解包 为什么要强制解包？

1. 可选项是其实对其他类型的一种包装
2. 为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)

空合运算符

1. a （可选项） b（可选项或不是可选项）
2. a 和 b的存储类型要相同
3. a 不为 nil 返回 a 反之 返回b（返回类型取决于b）
4. 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时会报警告

解决办法：

1. 强制解包
2. String(describing:)函数 （只是不报警告，print依然是Optional(value)类型）
3. value??0

Swift学习日记7.0