七、枚举类型可选项

作者: 爱玩游戏的iOS菜鸟 | 来源:发表于2020-01-06 18:41 被阅读0次

枚举

枚举基本用法

//写法一
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语句为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

可选类型在字符串插值或直接print时会报警告

解决办法：

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

Swift学习日记7.0

网友评论

Swift5.1语法学习

本文标题：七、枚举类型可选项

本文链接：https://www.haomeiwen.com/subject/takkactx.html

延伸阅读

深度阅读

您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

七、枚举类型可选项

枚举

枚举基本用法

枚举关联值

枚举原始值

递归枚举

MemoryLayout

窥探枚举成员的内存布局

如何窥探内存？

可选项 (可选类型)

什么是可选类型

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

可选项绑定

空合运算符

guard语句

隐式解包

多重可选类型

可选类型在字符串插值或直接print时会报警告

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Swift5.1语法学习

七、枚举类型 可选项

枚举

枚举基本用法

枚举关联值

枚举原始值

递归枚举

MemoryLayout

窥探枚举成员的内存布局

如何窥探内存？

可选项 (可选类型)

什么是可选类型

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

可选项绑定

空合运算符

guard语句

隐式解包

多重可选类型

可选类型在字符串插值 或直接print时会报警告

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Swift5.1语法学习

七、枚举类型可选项

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

可选类型在字符串插值或直接print时会报警告