Swift语法--枚举和可选项

基本用法

enum Direction{
  case north
  case south
  case east
  case west
}
或者
enum Direction{
  case north, south, east, west
}

var dir = Direction.west
dir =  Direction. east
dir = .north
print(dir)//north

可以用在switch语法中
switch dir{
   case .north:
      print("north")
   case .south:
      print("south")
   case .east:
      print("east")
   case .west:
      print("west")
}

关联值

有时会将枚举的成员值跟其他类型的关联存储在一起，会非常有用
必要时let也可以改为var

enum Score {
    case points(Int)
    case grade(Character)
}
var score = Score.points(96)
score = .grade("A")
print("score = \(score)");//打印结果：score = grade("A")

switch score {
  case let .points(i)://常量写let，也可以变量var
      print(i,"points")
  case let .grade(i):
      print("grade",i)
}

enum Date{
    case digit(year:Int,month:Int,day:Int)
    case string(String)
}
var date = Date.digit(year: 2021, month: 12, day: 20)
date = .string("2021-12-21")
switch date{
    case .digit(let year, let month,let day):
    //case let .digit(year, month,day)://let可以放在前边也可以放在后边
        print(year,month,day)
    case let .string(value):
        print(value)
}

原始值

枚举成员可以使用相同类型的默认值预先关联，这个默认值叫做：原始值

enum PokerSuit:Character{
    case spade = "♠️"
    case heart = "♥️"
    case diamond = "♦️"
    case club = "♣️"
}
var suit = PokerSuit.spade
print(suit)//spade
print(suit.rawValue)//♠️,取原始值
print(PokerSuit.club.rawValue)//♣️

enum Grade:String{
    case perfect = "A"
    case great = "B"
    case good = "C"
    case bad = "D"
}
print(Grade.perfect.rawValue)//A
print(Grade.great.rawValue)//B
print(Grade.good.rawValue)//C
print(Grade.bad.rawValue)//D

print(Grade.perfect)//perfect
print(Grade.great)//great
print(Grade.good)//good
print(Grade.bad)//bad

隐式原始值

如果枚举的原始值类型是 Int、String，Swift会自动分配原始值

enum Direction:String{
    case north = "north"
    case south = "south"
    case east = "east"
    case west = "west"
}
等价于
enum Direction :String{
    case north, south, east, west
}
print(Direction.north)//north
print(Direction.north.rawValue)//north

enum Season:Int{
    case spring,summer,autumn,winter
}
print(Season.spring.rawValue)//0
print(Season.summer.rawValue)//1
print(Season.autumn.rawValue)//2
print(Season.winter.rawValue)//3

如果给定原始值，则下一个递增

enum Season:Int{
    case spring=1,summer,autumn=4,winter
}
print(Season.spring.rawValue)//1
print(Season.summer.rawValue)//2
print(Season.autumn.rawValue)//4
print(Season.winter.rawValue)//5

递归枚举

indirect enum ArithExpr{
    case number(Int)
    case sum(ArithExpr,ArithExpr)
    case difference(ArithExpr,ArithExpr)
}
或者写成
enum ArithExpr{
    case number(Int)
    indirect case sum(ArithExpr,ArithExpr)
    indirect case difference(ArithExpr,ArithExpr)
}

indirect enum ArithExpr{
    case number(Int)
    case sum(ArithExpr,ArithExpr)
    case difference(ArithExpr,ArithExpr)
}

let five = ArithExpr.number(5)
let four = ArithExpr.number(4)
let two = ArithExpr.number(2)
let sum = ArithExpr.sum(five, four)
let difference = ArithExpr.difference(sum, two)

func calculate(_ expr:ArithExpr) -> Int{
    switch expr {
    case let .number(value):
        return value
    case let .sum(left, right):
        return calculate(left) + calculate(right)
    case let .difference(left, right):
        return calculate(left) - calculate(right)
    }
}
print(calculate(difference))//7

MemoryLayout

可以使用MemoryLayout获取数据类型占用的内存大小

MemoryLayout<Int>.size//8，跟平台有关，平台是64位，所以占8字节
MemoryLayout<Int>.stride//8
MemoryLayout<Int>.alignment//8，内存对齐参数（和数据结构最大的那个，保持一致）

var age = 10
MemoryLayout.size(ofValue: age)//8
MemoryLayout.stride(ofValue: age)//8
MemoryLayout.alignment(ofValue: age)//8

enum Password{
    case number(Int,Int,Int,Int)
    case other
}
var pwd = Password.number(5,6,4,7)//内存为32个字节
pwd = .other//内存为32个字节
MemoryLayout<Password>.size//33个字节，实际用到的空间大小（numbers是32，other是1）
MemoryLayout<Password>.stride//40个字节，分配占用的空间大小
MemoryLayout<Password>.alignment//8个字节，对齐参数（和数据结构最大的那个，保持一致）

enum Season{
    case spring,summer,autumn,winter
}
MemoryLayout<Season>.size//1
MemoryLayout<Season>.stride//1
MemoryLayout<Season>.alignment//1

enum Season:Int{
    case spring=1,summer,autumn,winter
}
MemoryLayout<Season>.size//1
MemoryLayout<Season>.stride//1
MemoryLayout<Season>.alignment//1

关联值和原始值的区别
关联值：允许自己传值的，存储在枚举变量内存里面
原始值：不会放在枚举内存变量，枚举类型只占用一个字节，相当于存储一个tag值，去区分是哪个枚举值就可以了

enum Password{
    case number(Int,Int,Bool,Int)
    case other
}
print(MemoryLayout<Password>.size)//32,(32的原因是内存对齐为8，第三位需要跳过8个字节，而bool只需要占用1个字节，剩余的7个字节可以给枚举区分用，所以不需要额外多加一个字节)
print(MemoryLayout<Password>.stride)//32
print(MemoryLayout<Password>.alignment)//8

enum Password{
    case number(Int,Int,Int,Bool)
    case other
}
print(MemoryLayout<Password>.size)//25
print(MemoryLayout<Password>.stride)//32
print(MemoryLayout<Password>.alignment)//8

可选项

可选项，一般也叫可选类型，它允许将值设置为nil
在类型名称后面加个 问号？来定义一个可选项

var age:Int
print(age)
报错，因为age没有初始值
var age:Int？
print(age)
不报错，因为有初始值，等价于var age:Int = nil

var age:Int 和 var age:Int = 0是不等价的

var name : String? = "jack"
name = nil

var age:Int? //默认就是nil
age = 10
age = nil

var array = [1,15,40,29]
func get(_ index:Int) -> Int?{
    if index<0 || index >= array.count {
        return nil
    }
    return array[index]
}
print(get(1))//Optional(15)
print(get(-1))//nil
print(get(4))//nil

强制解包

可选项是对其他类型的一层包装，可以将它理解为一个盒子
- 如果为nil，那么它是个空盒子
- 如果不为nil，那么盒子里装的是：被包装类型的数据
如果要从可选项中取出被包装的数据（将盒子里装的东西取出来），需要使用感叹号！进行强制解包

var age:Int? = 10
var num = age + 20
//报错：Value of optional type 'Int?' must be unwrapped to a value of type 'Int',因为age是一个可选类型，可以理解为一个盒子，不能拿盒子直接来操作，要把盒子里的内容拿出来，要用到`！`进行强制解包取出内容
var num = age! + 20

如果对值为nil的可选项（空盒子）进行强制解包，将会产生运行时错误，所以在强制解包时要确定确实有值才可以强制解包

var age:Int?
age!
//报错：Fatal error: Unexpectedly found nil while unwrapping an Optional value

判断可选项是否包含值

let number = Int("123")
if number != nil{
    print("字符串转换整数成功：\(number!)")
}else{
    print("字符串转换整数失败")
}

可选项绑定

可以使用可选项绑定来判断可选项是否包含值
- 如果包含就自动解包，把值赋给一个临时的常量（let）或者变量（var），并返回true，否则返回false

if let number = Int("123") {
    print("字符串转换整数成功：\(number)")
    //number是强制解包之后的Int值
    //number作用域仅限于这个大括号
}else{
    print("字符串转换整数失败")
}//字符串转换整数成功：123

enum Season:Int {
    case spring = 1,summer,autumn,winter
}

if let season = Season(rawValue: 6) {
    switch season {
    case .spring:
        print("the season is spring")
    default:
        print("the season is other")
    }
}else{
    print("no such season")
}

可选项绑定的与条件用，不能用&&

等价写法
if let first = Int("4") {
    if let second = Int("42") {
        if first<second && second<100 {
            print("\(first) < \(second) < 100")
        }
    }
}
//可选项绑定的与条件用`，`不能用&&
if let first = Int("4"),let second = Int("42"),first<second&&second<100 {
    print("\(first)<\(second)<100")
}

`while`循环中使用可选项绑定

var strs = ["10","20","abc","-20","-30"]
var index = 0
var sum = 0
while let num = Int(strs[index]),num>0 {
    sum += num
    index += 1
}
print(sum)

空合并运算符 `??`

a ?? b
- a是可选项
- b是可选项或者不是可选项
- b跟a的存储类型必须相同(如果a为int?，那么b也必须为int?或者int)
- 如果a不为nil，则返回a
- 如果a为nil，就返回b
- 如果b不是可选项，返回a时会自动解包

let a:Int? = 1
let b:Int? = 2
let c = a ?? b
print(c)
//c是Int?,Optional(1)

let a:Int? = nil
let b:Int? = 2
let c = a ?? b
print(c)
//c是Int?,Optional(2)

let a:Int? = nil
let b:Int? = nil
let c = a ?? b
print(c)
//c是Int?,nil

let a:Int? = 1
let b:Int = 2
let c = a ?? b
print(c)
//c是Int,1

总结下来就是说：空合并运算符返回的类型取决于b的类型

多个`??`一起使用

let a:Int? = 1
let b:Int? = 2
let c = a ?? b ?? 3
print(c)
//c是Int,1

let a:Int? = nil
let b:Int? = 2
let c = a ?? b ?? 3
print(c)
//c是Int,2

let a:Int? = nil
let b:Int? = nil
let c = a ?? b ?? 3
print(c)
//c是Int,3

//返回类型看最后边的类型

`??`跟`if let`配合使用

let a:Int? = nil
let b:Int? = 2
let c = a ?? b ?? 3
if let c = a ?? b{
    print(c)
}//2

//类似于if a != nil || b != nil

`if`语句实现登录

func login(_ info:[String:String]){
    let username:String
    if let tmp = info["username"] {
        username = tmp
    }else{
        print("请输入用户名")
        return
    }
    let password:String
    if let tmp = info["password"] {
        password = tmp
    }else{
        print("请输入密码")
        return
    }
    print("用户名：\(username)", "密码：\(password)","登录ing")
}

login(["username":"jack","password":"123456"])//用户名：jack 密码：123456 登录ing
login(["password":"123456"])//请输入用户名
login(["username":"jack"])//请输入密码

`guard`语句

guard 条件 else{
    //do something....
    退出当前作用域(必须写下面的退出当前作用域代码，不然会报错)
    //return、break、continue、throw error
}

当guard语句的条件为false时，就会执行大括号里面的代码
当guard语句的条件为true时，就会跳过guard语句
guard语句特别适合用来“提前退出”
当使用guard语句进行可选项绑定时，绑定的常量（let）、变量（var）也能在外层作用域中使用

func login(_ info:[String:String]){
    guard let username = info["username"] else {
        print("请输入用户名")
        return
    }
    guard let password = info["password"] else {
        print("请输入密码")
        return
    }
    print("用户名：\(username)", "密码：\(password)","登录ing")
}
login(["username":"jack","password":"123456"])//用户名：jack 密码：123456 登录ing
login(["password":"123456"])//请输入用户名
login(["username":"jack"])//请输入密码

隐式解包

在某些情况下，可选项一旦被设定值之后，就会一直拥有值
在这种情况下，可以去掉检查，也不必每次访问的时候都进行解包，因为他能确定每次访问的时候都有值
可以在类型后面加个感叹号!定义一个隐式解包的可选项
总结：可以确定可选项一直有值的情况下可以用隐式解包

//隐式解包的可选项
let num1:Int! = 10
let num2:Int = num1
print(num2)

let num1:Int! = 10
let num2:Int = num1
if num1 != nil {
    print(num1+6)//16
}
if let num3 = num1 {
    print(num3)
}

let num1:Int! = nil
//Fatal error: Unexpectedly found nil while implicitly unwrapping an Optional value
let num2:Int = num1

字符串插值

可选项在字符串插值或者直接打印时，编译器会发出警告

var age:Int? = 10
print("my age is \(age)")//my age is Optional(10)
//String interpolation produces a debug description for an optional value; did you mean to make this explicit?
print(age)//Optional(10)
//Expression implicitly coerced from 'Int?' to 'Any'

至少有三种方法消除警告

print("my age is \(age!)")//my age is 10
print("my age is \(String(describing: age))")//my age is Optional(10)
print("my age is \(age ?? 0)")//my age is 10

多重可选项

var num1:Int? = 10//包装了一个Int类型的可选类型
var num2:Int?? = num1//包装了一个可选类型的可选类型
var num3:Int?? = 10
print(num2 == num3)//true

var num1:Int? = nil
var num2:Int?? = num1
var num3:Int?? = nil
print(num2 == num3)//false
print(num1 == num3)//false,返回值类型不同
print((num2 ?? 1) ?? 2)//2
print((num3 ?? 1) ?? 2)//1

可以使用lldb命令frame variable -R或者fr v -R查看区别

枚举变量的内存布局

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

enum TestEnum {
    case test1(Int,Int,Int)
    case test2(Int,Int)
    case test3(Int)
    case test4(Bool)
    case test5
}

var e = TestEnum.test1(1, 2, 3)
//01 00 00 00 00 00 00 00
//02 00 00 00 00 00 00 00
//03 00 00 00 00 00 00 00
//00
//00 00 00 00 00 00 00

e = .test2(4, 5)
//04 00 00 00 00 00 00 00
//05 00 00 00 00 00 00 00
//00 00 00 00 00 00 00 00
//01
//00 00 00 00 00 00 00

e = .test3(6)
//06 00 00 00 00 00 00 00
//00 00 00 00 00 00 00 00
//00 00 00 00 00 00 00 00
//02
//00 00 00 00 00 00 00

e = .test4(true)
//01 00 00 00 00 00 00 00
//00 00 00 00 00 00 00 00
//00 00 00 00 00 00 00 00
//03
//00 00 00 00 00 00 00

e = .test5
//00 00 00 00 00 00 00 00
//00 00 00 00 00 00 00 00
//00 00 00 00 00 00 00 00
//04
//00 00 00 00 00 00 00
大小端：高高低低存储

enum TestEnum {
    case test
}
var t = TestEnum.test

print(MemoryLayout<TestEnum>.size)//0
print(MemoryLayout<TestEnum>.stride)//1
print(MemoryLayout<TestEnum>.alignment)//1
只有一个case，不需要字节存储成员值

enum TestEnum {
    case test(Int)
}
var t = TestEnum.test(10)

print(MemoryLayout<TestEnum>.size)//8
print(MemoryLayout<TestEnum>.stride)//8
print(MemoryLayout<TestEnum>.alignment)//8

enum TestEnum {
    case test1,test2
}
var t = TestEnum.test1

print(MemoryLayout<TestEnum>.size)//1
print(MemoryLayout<TestEnum>.stride)//1
print(MemoryLayout<TestEnum>.alignment)//1

最后编辑于：2022.02.17 14:58:42

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 206,839评论 6赞 482
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 88,543评论 2赞 382
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 153,116评论 0赞 344
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 55,371评论 1赞 279
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 64,384评论 5赞 374
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 49,111评论 1赞 285
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 38,416评论 3赞 400
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 37,053评论 0赞 259
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 43,558评论 1赞 300
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 36,007评论 2赞 325
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 38,117评论 1赞 334
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 33,756评论 4赞 324
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 39,324评论 3赞 307
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 30,315评论 0赞 19
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 31,539评论 1赞 262
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 45,578评论 2赞 355
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 42,877评论 2赞 345

Swift语法--枚举和可选项

基本用法

关联值

原始值

隐式原始值

递归枚举

MemoryLayout

可选项

强制解包

判断可选项是否包含值

可选项绑定

while循环中使用可选项绑定

空合并运算符 ??

多个??一起使用

??跟if let配合使用

if语句实现登录

guard语句

隐式解包

字符串插值

多重可选项

枚举变量的内存布局

推荐阅读更多精彩内容

`while`循环中使用可选项绑定

空合并运算符 `??`

多个`??`一起使用

`??`跟`if let`配合使用

`if`语句实现登录

`guard`语句